1 using System;
2 using System.Collections;
3 using System.Text.Parsing;
4
5
6
7 namespace cmsx.intermediate
8 {
9 public class IntermediateCodeFileGrammar : System.Text.Parsing.Grammar
10 {
11 public IntermediateCodeFileGrammar() : this(new ParsingDomain())
12 {
13 }
14 public IntermediateCodeFileGrammar(ParsingDomain* parsingDomain) : base(ToUtf32("IntermediateCodeFileGrammar"), parsingDomain->GetNamespaceScope(ToUtf32("cmsx.intermediate")), parsingDomain)
15 {
16 SetOwner(0);
17 keywords0.Add(ToUtf32("void"));
18 keywords0.Add(ToUtf32("byte"));
19 keywords0.Add(ToUtf32("float"));
20 keywords0.Add(ToUtf32("uint"));
21 keywords0.Add(ToUtf32("bool"));
22 keywords0.Add(ToUtf32("long"));
23 keywords0.Add(ToUtf32("ushort"));
24 keywords0.Add(ToUtf32("ulong"));
25 keywords0.Add(ToUtf32("double"));
26 keywords0.Add(ToUtf32("int"));
27 keywords0.Add(ToUtf32("sbyte"));
28 keywords0.Add(ToUtf32("short"));
29 RegisterParsingDomain(parsingDomain);
30 parsingDomain->AddGrammar(this);
31 CreateRules();
32 Link();
33 }
34 public void Parse(const uchar* start, const uchar* end, int fileIndex, const string& fileName, cmsx.intermediate.Context* context)
35 {
36 Scanner scanner(start, end, fileName, fileIndex, SkipRule());
37 UniquePtr<XmlLog> xmlLog;
38 if (Log() != null)
39 {
40 xmlLog.Reset(new XmlLog(*Log(), MaxLogLineLength()));
41 scanner.SetLog(xmlLog.Get());
42 xmlLog->WriteBeginRule( u"parse");
43 xmlLog->IncIndent();
44 }
45 Stack<UniquePtr<Object>> stack;
46 UniquePtr<ParsingData> parsingData(new ParsingData(Domain()->NumRules()));
47 scanner.SetParsingData(parsingData.Get());
48 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context)));
49 Match match = base->Parse(scanner, stack, parsingData.Get());
50 Span stop = scanner.GetSpan();
51 if (Log() != null)
52 {
53 xmlLog->DecIndent();
54 xmlLog->WriteEndRule( u"parse");
55 }
56 if (!match.Hit() || stop.start != cast<int>(end - start))
57 {
58 if (StartRule() != null)
59 {
60 throw ExpectationFailure(StartRule()->Info(), fileName, stop, start, end);
61 }
62 else
63 {
64 throw ParsingException("grammar '" + ToUtf8(Name()) + "' has no start rule", fileName, scanner.GetSpan(), start, end);
65 }
66 }
67 }
68
69 public class IntermediateCodeFileRule : System.Text.Parsing.RuleParser
70 {
71 public IntermediateCodeFileRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
72 {
73 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
74 }
75 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
76 {
77 parsingData->PushContext(Id(), new Context());
78 Context* context = cast<Context*>(parsingData->GetContext(Id()));
79 UniquePtr<Object> context_value = stack.Pop();
80 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
81 }
82 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
83 {
84 parsingData->PopContext(Id());
85 }
86 public override void Link()
87 {
88 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
89 a0ActionParser->SetAction(A0Action);
90 NonterminalParser* compileUnitHeaderNonterminalParser = GetNonterminal(ToUtf32("CompileUnitHeader"));
91 compileUnitHeaderNonterminalParser->SetPre(PreCompileUnitHeader);
92 NonterminalParser* typeDeclarationsNonterminalParser = GetNonterminal(ToUtf32("TypeDeclarations"));
93 typeDeclarationsNonterminalParser->SetPre(PreTypeDeclarations);
94 NonterminalParser* dataDefinitionsNonterminalParser = GetNonterminal(ToUtf32("DataDefinitions"));
95 dataDefinitionsNonterminalParser->SetPre(PreDataDefinitions);
96 NonterminalParser* functionsNonterminalParser = GetNonterminal(ToUtf32("Functions"));
97 functionsNonterminalParser->SetPre(PreFunctions);
98 NonterminalParser* metadataNonterminalParser = GetNonterminal(ToUtf32("Metadata"));
99 metadataNonterminalParser->SetPre(PreMetadata);
100 }
101 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
102 {
103 Context* context = cast<Context*>(parsingData->GetContext(Id()));
104 context->context->SetFileName(fileName);
105 }
106 public void PreCompileUnitHeader(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
107 {
108 Context* context = cast<Context*>(parsingData->GetContext(Id()));
109 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
110 }
111 public void PreTypeDeclarations(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
112 {
113 Context* context = cast<Context*>(parsingData->GetContext(Id()));
114 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
115 }
116 public void PreDataDefinitions(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
117 {
118 Context* context = cast<Context*>(parsingData->GetContext(Id()));
119 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
120 }
121 public void PreFunctions(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
122 {
123 Context* context = cast<Context*>(parsingData->GetContext(Id()));
124 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
125 }
126 public void PreMetadata(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
127 {
128 Context* context = cast<Context*>(parsingData->GetContext(Id()));
129 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
130 }
131 public class Context : System.Text.Parsing.Context
132 {
133 public Context() : context()
134 {
135 }
136 public cmsx.intermediate.Context* context;
137 }
138 }
139
140 public class CompileUnitHeaderRule : System.Text.Parsing.RuleParser
141 {
142 public CompileUnitHeaderRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
143 {
144 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
145 AddLocalVariable(AttrOrVar(ToUtf32("string"), ToUtf32("compileUnitId")));
146 AddLocalVariable(AttrOrVar(ToUtf32("MDStructRef*"), ToUtf32("mdRef")));
147 }
148 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
149 {
150 parsingData->PushContext(Id(), new Context());
151 Context* context = cast<Context*>(parsingData->GetContext(Id()));
152 UniquePtr<Object> context_value = stack.Pop();
153 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
154 }
155 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
156 {
157 parsingData->PopContext(Id());
158 }
159 public override void Link()
160 {
161 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
162 a0ActionParser->SetAction(A0Action);
163 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
164 a1ActionParser->SetAction(A1Action);
165 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
166 a2ActionParser->SetAction(A2Action);
167 NonterminalParser* mDStructRefNonterminalParser = GetNonterminal(ToUtf32("MDStructRef"));
168 mDStructRefNonterminalParser->SetPre(PreMDStructRef);
169 mDStructRefNonterminalParser->SetPost(PostMDStructRef);
170 }
171 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
172 {
173 Context* context = cast<Context*>(parsingData->GetContext(Id()));
174 context->context->SetCompileUnitInfo(context->compileUnitId, context->mdRef);
175 }
176 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
177 {
178 Context* context = cast<Context*>(parsingData->GetContext(Id()));
179 context->compileUnitId = ToUtf8(ustring(matchBegin, matchEnd));
180 }
181 public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
182 {
183 Context* context = cast<Context*>(parsingData->GetContext(Id()));
184 context->mdRef = context->fromMDStructRef;
185 }
186 public void PreMDStructRef(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
187 {
188 Context* context = cast<Context*>(parsingData->GetContext(Id()));
189 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
190 }
191 public void PostMDStructRef(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
192 {
193 Context* context = cast<Context*>(parsingData->GetContext(Id()));
194 if (matched)
195 {
196 UniquePtr<Object> fromMDStructRef_value = stack.Pop();
197 context->fromMDStructRef = *cast<ValueObject<MDStructRef*>*>(fromMDStructRef_value.Get());
198 }
199 }
200 public class Context : System.Text.Parsing.Context
201 {
202 public Context() : context(), compileUnitId(), mdRef(), fromMDStructRef()
203 {
204 }
205 public cmsx.intermediate.Context* context;
206 public string compileUnitId;
207 public MDStructRef* mdRef;
208 public MDStructRef* fromMDStructRef;
209 }
210 }
211
212 public class TypeDeclarationsRule : System.Text.Parsing.RuleParser
213 {
214 public TypeDeclarationsRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
215 {
216 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
217 }
218 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
219 {
220 parsingData->PushContext(Id(), new Context());
221 Context* context = cast<Context*>(parsingData->GetContext(Id()));
222 UniquePtr<Object> context_value = stack.Pop();
223 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
224 }
225 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
226 {
227 parsingData->PopContext(Id());
228 }
229 public override void Link()
230 {
231 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
232 a0ActionParser->SetAction(A0Action);
233 NonterminalParser* typeDeclarationNonterminalParser = GetNonterminal(ToUtf32("TypeDeclaration"));
234 typeDeclarationNonterminalParser->SetPre(PreTypeDeclaration);
235 }
236 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
237 {
238 Context* context = cast<Context*>(parsingData->GetContext(Id()));
239 context->context->ResolveTypes();
240 }
241 public void PreTypeDeclaration(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
242 {
243 Context* context = cast<Context*>(parsingData->GetContext(Id()));
244 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
245 }
246 public class Context : System.Text.Parsing.Context
247 {
248 public Context() : context()
249 {
250 }
251 public cmsx.intermediate.Context* context;
252 }
253 }
254
255 public class DataDefinitionsRule : System.Text.Parsing.RuleParser
256 {
257 public DataDefinitionsRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
258 {
259 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
260 }
261 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
262 {
263 parsingData->PushContext(Id(), new Context());
264 Context* context = cast<Context*>(parsingData->GetContext(Id()));
265 UniquePtr<Object> context_value = stack.Pop();
266 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
267 }
268 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
269 {
270 parsingData->PopContext(Id());
271 }
272 public override void Link()
273 {
274 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
275 a0ActionParser->SetAction(A0Action);
276 NonterminalParser* dataDefinitionNonterminalParser = GetNonterminal(ToUtf32("DataDefinition"));
277 dataDefinitionNonterminalParser->SetPre(PreDataDefinition);
278 }
279 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
280 {
281 Context* context = cast<Context*>(parsingData->GetContext(Id()));
282 context->context->ValidateGlobalVariables();
283 }
284 public void PreDataDefinition(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
285 {
286 Context* context = cast<Context*>(parsingData->GetContext(Id()));
287 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
288 }
289 public class Context : System.Text.Parsing.Context
290 {
291 public Context() : context()
292 {
293 }
294 public cmsx.intermediate.Context* context;
295 }
296 }
297
298 public class FunctionsRule : System.Text.Parsing.RuleParser
299 {
300 public FunctionsRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
301 {
302 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
303 }
304 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
305 {
306 parsingData->PushContext(Id(), new Context());
307 Context* context = cast<Context*>(parsingData->GetContext(Id()));
308 UniquePtr<Object> context_value = stack.Pop();
309 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
310 }
311 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
312 {
313 parsingData->PopContext(Id());
314 }
315 public override void Link()
316 {
317 NonterminalParser* functionNonterminalParser = GetNonterminal(ToUtf32("Function"));
318 functionNonterminalParser->SetPre(PreFunction);
319 }
320 public void PreFunction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
321 {
322 Context* context = cast<Context*>(parsingData->GetContext(Id()));
323 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
324 }
325 public class Context : System.Text.Parsing.Context
326 {
327 public Context() : context()
328 {
329 }
330 public cmsx.intermediate.Context* context;
331 }
332 }
333
334 public class FunctionRule : System.Text.Parsing.RuleParser
335 {
336 public FunctionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
337 {
338 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
339 }
340 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
341 {
342 parsingData->PushContext(Id(), new Context());
343 Context* context = cast<Context*>(parsingData->GetContext(Id()));
344 UniquePtr<Object> context_value = stack.Pop();
345 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
346 }
347 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
348 {
349 parsingData->PopContext(Id());
350 }
351 public override void Link()
352 {
353 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
354 a0ActionParser->SetAction(A0Action);
355 NonterminalParser* functionNonterminalParser = GetNonterminal(ToUtf32("function"));
356 functionNonterminalParser->SetPre(Prefunction);
357 functionNonterminalParser->SetPost(Postfunction);
358 NonterminalParser* basicBlockNonterminalParser = GetNonterminal(ToUtf32("BasicBlock"));
359 basicBlockNonterminalParser->SetPre(PreBasicBlock);
360 }
361 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
362 {
363 Context* context = cast<Context*>(parsingData->GetContext(Id()));
364 context->context->SetCurrentFunction(context->fromfunction);
365 }
366 public void Prefunction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
367 {
368 Context* context = cast<Context*>(parsingData->GetContext(Id()));
369 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
370 }
371 public void Postfunction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
372 {
373 Context* context = cast<Context*>(parsingData->GetContext(Id()));
374 if (matched)
375 {
376 UniquePtr<Object> fromfunction_value = stack.Pop();
377 context->fromfunction = *cast<ValueObject<Function*>*>(fromfunction_value.Get());
378 }
379 }
380 public void PreBasicBlock(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
381 {
382 Context* context = cast<Context*>(parsingData->GetContext(Id()));
383 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
384 stack.Push(UniquePtr<Object>(new ValueObject<Function*>(context->fromfunction)));
385 }
386 public class Context : System.Text.Parsing.Context
387 {
388 public Context() : context(), fromfunction()
389 {
390 }
391 public cmsx.intermediate.Context* context;
392 public Function* fromfunction;
393 }
394 }
395
396 public class FunctionHeaderRule : System.Text.Parsing.RuleParser
397 {
398 public FunctionHeaderRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
399 {
400 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
401 SetValueTypeName(ToUtf32("Function*"));
402 AddLocalVariable(AttrOrVar(ToUtf32("bool"), ToUtf32("once")));
403 }
404 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
405 {
406 parsingData->PushContext(Id(), new Context());
407 Context* context = cast<Context*>(parsingData->GetContext(Id()));
408 UniquePtr<Object> context_value = stack.Pop();
409 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
410 }
411 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
412 {
413 Context* context = cast<Context*>(parsingData->GetContext(Id()));
414 if (matched)
415 {
416 stack.Push(UniquePtr<Object>(new ValueObject<Function*>(context->value)));
417 }
418 parsingData->PopContext(Id());
419 }
420 public override void Link()
421 {
422 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
423 a0ActionParser->SetAction(A0Action);
424 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
425 a1ActionParser->SetAction(A1Action);
426 NonterminalParser* functionTypeNonterminalParser = GetNonterminal(ToUtf32("functionType"));
427 functionTypeNonterminalParser->SetPre(PrefunctionType);
428 functionTypeNonterminalParser->SetPost(PostfunctionType);
429 NonterminalParser* functionIdNonterminalParser = GetNonterminal(ToUtf32("functionId"));
430 functionIdNonterminalParser->SetPost(PostfunctionId);
431 NonterminalParser* mdNonterminalParser = GetNonterminal(ToUtf32("md"));
432 mdNonterminalParser->SetPre(Premd);
433 mdNonterminalParser->SetPost(Postmd);
434 }
435 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
436 {
437 Context* context = cast<Context*>(parsingData->GetContext(Id()));
438 context->once = true;
439 }
440 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
441 {
442 Context* context = cast<Context*>(parsingData->GetContext(Id()));
443 context->value = context->context->AddFunction(span.lineNumber, context->fromfunctionType, ToUtf8(context->fromfunctionId), context->once, context->frommd);
444 }
445 public void PrefunctionType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
446 {
447 Context* context = cast<Context*>(parsingData->GetContext(Id()));
448 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
449 }
450 public void PostfunctionType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
451 {
452 Context* context = cast<Context*>(parsingData->GetContext(Id()));
453 if (matched)
454 {
455 UniquePtr<Object> fromfunctionType_value = stack.Pop();
456 context->fromfunctionType = *cast<ValueObject<Type*>*>(fromfunctionType_value.Get());
457 }
458 }
459 public void PostfunctionId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
460 {
461 Context* context = cast<Context*>(parsingData->GetContext(Id()));
462 if (matched)
463 {
464 UniquePtr<Object> fromfunctionId_value = stack.Pop();
465 context->fromfunctionId = *cast<ValueObject<ustring>*>(fromfunctionId_value.Get());
466 }
467 }
468 public void Premd(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
469 {
470 Context* context = cast<Context*>(parsingData->GetContext(Id()));
471 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
472 }
473 public void Postmd(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
474 {
475 Context* context = cast<Context*>(parsingData->GetContext(Id()));
476 if (matched)
477 {
478 UniquePtr<Object> frommd_value = stack.Pop();
479 context->frommd = *cast<ValueObject<MDStructRef*>*>(frommd_value.Get());
480 }
481 }
482 public class Context : System.Text.Parsing.Context
483 {
484 public Context() : context(), value(), once(), fromfunctionType(), fromfunctionId(), frommd()
485 {
486 }
487 public cmsx.intermediate.Context* context;
488 public Function* value;
489 public bool once;
490 public Type* fromfunctionType;
491 public ustring fromfunctionId;
492 public MDStructRef* frommd;
493 }
494 }
495
496 public class BasicBlockRule : System.Text.Parsing.RuleParser
497 {
498 public BasicBlockRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
499 {
500 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
501 AddInheritedAttribute(AttrOrVar(ToUtf32("Function*"), ToUtf32("function")));
502 AddLocalVariable(AttrOrVar(ToUtf32("BasicBlock*"), ToUtf32("bb")));
503 }
504 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
505 {
506 parsingData->PushContext(Id(), new Context());
507 Context* context = cast<Context*>(parsingData->GetContext(Id()));
508 UniquePtr<Object> function_value = stack.Pop();
509 context->function = *cast<ValueObject<Function*>*>(function_value.Get());
510 UniquePtr<Object> context_value = stack.Pop();
511 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
512 }
513 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
514 {
515 parsingData->PopContext(Id());
516 }
517 public override void Link()
518 {
519 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
520 a0ActionParser->SetAction(A0Action);
521 NonterminalParser* idNonterminalParser = GetNonterminal(ToUtf32("id"));
522 idNonterminalParser->SetPost(Postid);
523 NonterminalParser* instructionLineNonterminalParser = GetNonterminal(ToUtf32("InstructionLine"));
524 instructionLineNonterminalParser->SetPre(PreInstructionLine);
525 }
526 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
527 {
528 Context* context = cast<Context*>(parsingData->GetContext(Id()));
529 context->bb = context->function->AddBasicBlock(context->fromid);
530 }
531 public void Postid(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
532 {
533 Context* context = cast<Context*>(parsingData->GetContext(Id()));
534 if (matched)
535 {
536 UniquePtr<Object> fromid_value = stack.Pop();
537 context->fromid = *cast<ValueObject<uint>*>(fromid_value.Get());
538 }
539 }
540 public void PreInstructionLine(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
541 {
542 Context* context = cast<Context*>(parsingData->GetContext(Id()));
543 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
544 stack.Push(UniquePtr<Object>(new ValueObject<BasicBlock*>(context->bb)));
545 }
546 public class Context : System.Text.Parsing.Context
547 {
548 public Context() : context(), function(), bb(), fromid()
549 {
550 }
551 public cmsx.intermediate.Context* context;
552 public Function* function;
553 public BasicBlock* bb;
554 public uint fromid;
555 }
556 }
557
558 public class InstructionLineRule : System.Text.Parsing.RuleParser
559 {
560 public InstructionLineRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
561 {
562 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
563 AddInheritedAttribute(AttrOrVar(ToUtf32("BasicBlock*"), ToUtf32("bb")));
564 }
565 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
566 {
567 parsingData->PushContext(Id(), new Context());
568 Context* context = cast<Context*>(parsingData->GetContext(Id()));
569 UniquePtr<Object> bb_value = stack.Pop();
570 context->bb = *cast<ValueObject<BasicBlock*>*>(bb_value.Get());
571 UniquePtr<Object> context_value = stack.Pop();
572 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
573 }
574 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
575 {
576 parsingData->PopContext(Id());
577 }
578 public override void Link()
579 {
580 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
581 a0ActionParser->SetAction(A0Action);
582 NonterminalParser* instructionNonterminalParser = GetNonterminal(ToUtf32("Instruction"));
583 instructionNonterminalParser->SetPre(PreInstruction);
584 instructionNonterminalParser->SetPost(PostInstruction);
585 NonterminalParser* lineInfoNonterminalParser = GetNonterminal(ToUtf32("lineInfo"));
586 lineInfoNonterminalParser->SetPre(PrelineInfo);
587 lineInfoNonterminalParser->SetPost(PostlineInfo);
588 }
589 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
590 {
591 Context* context = cast<Context*>(parsingData->GetContext(Id()));
592 context->bb->AddInstruction(context->fromInstruction, context->fromlineInfo);
593 }
594 public void PreInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
595 {
596 Context* context = cast<Context*>(parsingData->GetContext(Id()));
597 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
598 }
599 public void PostInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
600 {
601 Context* context = cast<Context*>(parsingData->GetContext(Id()));
602 if (matched)
603 {
604 UniquePtr<Object> fromInstruction_value = stack.Pop();
605 context->fromInstruction = *cast<ValueObject<Instruction*>*>(fromInstruction_value.Get());
606 }
607 }
608 public void PrelineInfo(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
609 {
610 Context* context = cast<Context*>(parsingData->GetContext(Id()));
611 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
612 }
613 public void PostlineInfo(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
614 {
615 Context* context = cast<Context*>(parsingData->GetContext(Id()));
616 if (matched)
617 {
618 UniquePtr<Object> fromlineInfo_value = stack.Pop();
619 context->fromlineInfo = *cast<ValueObject<MDStructRef*>*>(fromlineInfo_value.Get());
620 }
621 }
622 public class Context : System.Text.Parsing.Context
623 {
624 public Context() : context(), bb(), fromInstruction(), fromlineInfo()
625 {
626 }
627 public cmsx.intermediate.Context* context;
628 public BasicBlock* bb;
629 public Instruction* fromInstruction;
630 public MDStructRef* fromlineInfo;
631 }
632 }
633
634 public class InstructionRule : System.Text.Parsing.RuleParser
635 {
636 public InstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
637 {
638 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
639 SetValueTypeName(ToUtf32("Instruction*"));
640 }
641 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
642 {
643 parsingData->PushContext(Id(), new Context());
644 Context* context = cast<Context*>(parsingData->GetContext(Id()));
645 UniquePtr<Object> context_value = stack.Pop();
646 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
647 }
648 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
649 {
650 Context* context = cast<Context*>(parsingData->GetContext(Id()));
651 if (matched)
652 {
653 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
654 }
655 parsingData->PopContext(Id());
656 }
657 public override void Link()
658 {
659 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
660 a0ActionParser->SetAction(A0Action);
661 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
662 a1ActionParser->SetAction(A1Action);
663 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
664 a2ActionParser->SetAction(A2Action);
665 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
666 a3ActionParser->SetAction(A3Action);
667 ActionParser* a4ActionParser = GetAction(ToUtf32("A4"));
668 a4ActionParser->SetAction(A4Action);
669 ActionParser* a5ActionParser = GetAction(ToUtf32("A5"));
670 a5ActionParser->SetAction(A5Action);
671 ActionParser* a6ActionParser = GetAction(ToUtf32("A6"));
672 a6ActionParser->SetAction(A6Action);
673 ActionParser* a7ActionParser = GetAction(ToUtf32("A7"));
674 a7ActionParser->SetAction(A7Action);
675 ActionParser* a8ActionParser = GetAction(ToUtf32("A8"));
676 a8ActionParser->SetAction(A8Action);
677 ActionParser* a9ActionParser = GetAction(ToUtf32("A9"));
678 a9ActionParser->SetAction(A9Action);
679 NonterminalParser* storeInstructionNonterminalParser = GetNonterminal(ToUtf32("StoreInstruction"));
680 storeInstructionNonterminalParser->SetPre(PreStoreInstruction);
681 storeInstructionNonterminalParser->SetPost(PostStoreInstruction);
682 NonterminalParser* argInstructionNonterminalParser = GetNonterminal(ToUtf32("ArgInstruction"));
683 argInstructionNonterminalParser->SetPre(PreArgInstruction);
684 argInstructionNonterminalParser->SetPost(PostArgInstruction);
685 NonterminalParser* jumpInstructionNonterminalParser = GetNonterminal(ToUtf32("JumpInstruction"));
686 jumpInstructionNonterminalParser->SetPre(PreJumpInstruction);
687 jumpInstructionNonterminalParser->SetPost(PostJumpInstruction);
688 NonterminalParser* branchInstructionNonterminalParser = GetNonterminal(ToUtf32("BranchInstruction"));
689 branchInstructionNonterminalParser->SetPre(PreBranchInstruction);
690 branchInstructionNonterminalParser->SetPost(PostBranchInstruction);
691 NonterminalParser* procedureCallInstructionNonterminalParser = GetNonterminal(ToUtf32("ProcedureCallInstruction"));
692 procedureCallInstructionNonterminalParser->SetPre(PreProcedureCallInstruction);
693 procedureCallInstructionNonterminalParser->SetPost(PostProcedureCallInstruction);
694 NonterminalParser* retInstructionNonterminalParser = GetNonterminal(ToUtf32("RetInstruction"));
695 retInstructionNonterminalParser->SetPre(PreRetInstruction);
696 retInstructionNonterminalParser->SetPost(PostRetInstruction);
697 NonterminalParser* switchInstructionNonterminalParser = GetNonterminal(ToUtf32("SwitchInstruction"));
698 switchInstructionNonterminalParser->SetPre(PreSwitchInstruction);
699 switchInstructionNonterminalParser->SetPost(PostSwitchInstruction);
700 NonterminalParser* valueInstructionNonterminalParser = GetNonterminal(ToUtf32("ValueInstruction"));
701 valueInstructionNonterminalParser->SetPre(PreValueInstruction);
702 valueInstructionNonterminalParser->SetPost(PostValueInstruction);
703 NonterminalParser* noOperationInstructionNonterminalParser = GetNonterminal(ToUtf32("NoOperationInstruction"));
704 noOperationInstructionNonterminalParser->SetPre(PreNoOperationInstruction);
705 noOperationInstructionNonterminalParser->SetPost(PostNoOperationInstruction);
706 NonterminalParser* saveInstructionNonterminalParser = GetNonterminal(ToUtf32("SaveInstruction"));
707 saveInstructionNonterminalParser->SetPre(PreSaveInstruction);
708 saveInstructionNonterminalParser->SetPost(PostSaveInstruction);
709 }
710 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
711 {
712 Context* context = cast<Context*>(parsingData->GetContext(Id()));
713 context->value = context->fromStoreInstruction;
714 }
715 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
716 {
717 Context* context = cast<Context*>(parsingData->GetContext(Id()));
718 context->value = context->fromArgInstruction;
719 }
720 public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
721 {
722 Context* context = cast<Context*>(parsingData->GetContext(Id()));
723 context->value = context->fromJumpInstruction;
724 }
725 public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
726 {
727 Context* context = cast<Context*>(parsingData->GetContext(Id()));
728 context->value = context->fromBranchInstruction;
729 }
730 public void A4Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
731 {
732 Context* context = cast<Context*>(parsingData->GetContext(Id()));
733 context->value = context->fromProcedureCallInstruction;
734 }
735 public void A5Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
736 {
737 Context* context = cast<Context*>(parsingData->GetContext(Id()));
738 context->value = context->fromRetInstruction;
739 }
740 public void A6Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
741 {
742 Context* context = cast<Context*>(parsingData->GetContext(Id()));
743 context->value = context->fromSwitchInstruction;
744 }
745 public void A7Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
746 {
747 Context* context = cast<Context*>(parsingData->GetContext(Id()));
748 context->value = context->fromValueInstruction;
749 }
750 public void A8Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
751 {
752 Context* context = cast<Context*>(parsingData->GetContext(Id()));
753 context->value = context->fromNoOperationInstruction;
754 }
755 public void A9Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
756 {
757 Context* context = cast<Context*>(parsingData->GetContext(Id()));
758 context->value = context->fromSaveInstruction;
759 }
760 public void PreStoreInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
761 {
762 Context* context = cast<Context*>(parsingData->GetContext(Id()));
763 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
764 }
765 public void PostStoreInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
766 {
767 Context* context = cast<Context*>(parsingData->GetContext(Id()));
768 if (matched)
769 {
770 UniquePtr<Object> fromStoreInstruction_value = stack.Pop();
771 context->fromStoreInstruction = *cast<ValueObject<Instruction*>*>(fromStoreInstruction_value.Get());
772 }
773 }
774 public void PreArgInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
775 {
776 Context* context = cast<Context*>(parsingData->GetContext(Id()));
777 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
778 }
779 public void PostArgInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
780 {
781 Context* context = cast<Context*>(parsingData->GetContext(Id()));
782 if (matched)
783 {
784 UniquePtr<Object> fromArgInstruction_value = stack.Pop();
785 context->fromArgInstruction = *cast<ValueObject<Instruction*>*>(fromArgInstruction_value.Get());
786 }
787 }
788 public void PreJumpInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
789 {
790 Context* context = cast<Context*>(parsingData->GetContext(Id()));
791 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
792 }
793 public void PostJumpInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
794 {
795 Context* context = cast<Context*>(parsingData->GetContext(Id()));
796 if (matched)
797 {
798 UniquePtr<Object> fromJumpInstruction_value = stack.Pop();
799 context->fromJumpInstruction = *cast<ValueObject<Instruction*>*>(fromJumpInstruction_value.Get());
800 }
801 }
802 public void PreBranchInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
803 {
804 Context* context = cast<Context*>(parsingData->GetContext(Id()));
805 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
806 }
807 public void PostBranchInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
808 {
809 Context* context = cast<Context*>(parsingData->GetContext(Id()));
810 if (matched)
811 {
812 UniquePtr<Object> fromBranchInstruction_value = stack.Pop();
813 context->fromBranchInstruction = *cast<ValueObject<Instruction*>*>(fromBranchInstruction_value.Get());
814 }
815 }
816 public void PreProcedureCallInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
817 {
818 Context* context = cast<Context*>(parsingData->GetContext(Id()));
819 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
820 }
821 public void PostProcedureCallInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
822 {
823 Context* context = cast<Context*>(parsingData->GetContext(Id()));
824 if (matched)
825 {
826 UniquePtr<Object> fromProcedureCallInstruction_value = stack.Pop();
827 context->fromProcedureCallInstruction = *cast<ValueObject<Instruction*>*>(fromProcedureCallInstruction_value.Get());
828 }
829 }
830 public void PreRetInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
831 {
832 Context* context = cast<Context*>(parsingData->GetContext(Id()));
833 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
834 }
835 public void PostRetInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
836 {
837 Context* context = cast<Context*>(parsingData->GetContext(Id()));
838 if (matched)
839 {
840 UniquePtr<Object> fromRetInstruction_value = stack.Pop();
841 context->fromRetInstruction = *cast<ValueObject<Instruction*>*>(fromRetInstruction_value.Get());
842 }
843 }
844 public void PreSwitchInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
845 {
846 Context* context = cast<Context*>(parsingData->GetContext(Id()));
847 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
848 }
849 public void PostSwitchInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
850 {
851 Context* context = cast<Context*>(parsingData->GetContext(Id()));
852 if (matched)
853 {
854 UniquePtr<Object> fromSwitchInstruction_value = stack.Pop();
855 context->fromSwitchInstruction = *cast<ValueObject<SwitchInstruction*>*>(fromSwitchInstruction_value.Get());
856 }
857 }
858 public void PreValueInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
859 {
860 Context* context = cast<Context*>(parsingData->GetContext(Id()));
861 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
862 }
863 public void PostValueInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
864 {
865 Context* context = cast<Context*>(parsingData->GetContext(Id()));
866 if (matched)
867 {
868 UniquePtr<Object> fromValueInstruction_value = stack.Pop();
869 context->fromValueInstruction = *cast<ValueObject<Instruction*>*>(fromValueInstruction_value.Get());
870 }
871 }
872 public void PreNoOperationInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
873 {
874 Context* context = cast<Context*>(parsingData->GetContext(Id()));
875 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
876 }
877 public void PostNoOperationInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
878 {
879 Context* context = cast<Context*>(parsingData->GetContext(Id()));
880 if (matched)
881 {
882 UniquePtr<Object> fromNoOperationInstruction_value = stack.Pop();
883 context->fromNoOperationInstruction = *cast<ValueObject<Instruction*>*>(fromNoOperationInstruction_value.Get());
884 }
885 }
886 public void PreSaveInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
887 {
888 Context* context = cast<Context*>(parsingData->GetContext(Id()));
889 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
890 }
891 public void PostSaveInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
892 {
893 Context* context = cast<Context*>(parsingData->GetContext(Id()));
894 if (matched)
895 {
896 UniquePtr<Object> fromSaveInstruction_value = stack.Pop();
897 context->fromSaveInstruction = *cast<ValueObject<Instruction*>*>(fromSaveInstruction_value.Get());
898 }
899 }
900 public class Context : System.Text.Parsing.Context
901 {
902 public Context() : context(), value(), fromStoreInstruction(), fromArgInstruction(), fromJumpInstruction(), fromBranchInstruction(), fromProcedureCallInstruction(), fromRetInstruction(), fromSwitchInstruction(), fromValueInstruction(), fromNoOperationInstruction(), fromSaveInstruction()
903 {
904 }
905 public cmsx.intermediate.Context* context;
906 public Instruction* value;
907 public Instruction* fromStoreInstruction;
908 public Instruction* fromArgInstruction;
909 public Instruction* fromJumpInstruction;
910 public Instruction* fromBranchInstruction;
911 public Instruction* fromProcedureCallInstruction;
912 public Instruction* fromRetInstruction;
913 public SwitchInstruction* fromSwitchInstruction;
914 public Instruction* fromValueInstruction;
915 public Instruction* fromNoOperationInstruction;
916 public Instruction* fromSaveInstruction;
917 }
918 }
919
920 public class StoreInstructionRule : System.Text.Parsing.RuleParser
921 {
922 public StoreInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
923 {
924 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
925 SetValueTypeName(ToUtf32("Instruction*"));
926 }
927 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
928 {
929 parsingData->PushContext(Id(), new Context());
930 Context* context = cast<Context*>(parsingData->GetContext(Id()));
931 UniquePtr<Object> context_value = stack.Pop();
932 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
933 }
934 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
935 {
936 Context* context = cast<Context*>(parsingData->GetContext(Id()));
937 if (matched)
938 {
939 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
940 }
941 parsingData->PopContext(Id());
942 }
943 public override void Link()
944 {
945 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
946 a0ActionParser->SetAction(A0Action);
947 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
948 typeNonterminalParser->SetPre(Pretype);
949 typeNonterminalParser->SetPost(Posttype);
950 NonterminalParser* valNonterminalParser = GetNonterminal(ToUtf32("val"));
951 valNonterminalParser->SetPre(Preval);
952 valNonterminalParser->SetPost(Postval);
953 NonterminalParser* ptrTypeNonterminalParser = GetNonterminal(ToUtf32("ptrType"));
954 ptrTypeNonterminalParser->SetPre(PreptrType);
955 ptrTypeNonterminalParser->SetPost(PostptrType);
956 NonterminalParser* ptrNonterminalParser = GetNonterminal(ToUtf32("ptr"));
957 ptrNonterminalParser->SetPre(Preptr);
958 ptrNonterminalParser->SetPost(Postptr);
959 }
960 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
961 {
962 Context* context = cast<Context*>(parsingData->GetContext(Id()));
963 context->value = new StoreInstruction(context->fromval, context->fromptr, span.lineNumber);
964 }
965 public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
966 {
967 Context* context = cast<Context*>(parsingData->GetContext(Id()));
968 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
969 }
970 public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
971 {
972 Context* context = cast<Context*>(parsingData->GetContext(Id()));
973 if (matched)
974 {
975 UniquePtr<Object> fromtype_value = stack.Pop();
976 context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
977 }
978 }
979 public void Preval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
980 {
981 Context* context = cast<Context*>(parsingData->GetContext(Id()));
982 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
983 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->fromtype)));
984 }
985 public void Postval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
986 {
987 Context* context = cast<Context*>(parsingData->GetContext(Id()));
988 if (matched)
989 {
990 UniquePtr<Object> fromval_value = stack.Pop();
991 context->fromval = *cast<ValueObject<Value*>*>(fromval_value.Get());
992 }
993 }
994 public void PreptrType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
995 {
996 Context* context = cast<Context*>(parsingData->GetContext(Id()));
997 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
998 }
999 public void PostptrType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1000 {
1001 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1002 if (matched)
1003 {
1004 UniquePtr<Object> fromptrType_value = stack.Pop();
1005 context->fromptrType = *cast<ValueObject<Type*>*>(fromptrType_value.Get());
1006 }
1007 }
1008 public void Preptr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1009 {
1010 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1011 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
1012 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->fromptrType)));
1013 }
1014 public void Postptr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1015 {
1016 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1017 if (matched)
1018 {
1019 UniquePtr<Object> fromptr_value = stack.Pop();
1020 context->fromptr = *cast<ValueObject<Value*>*>(fromptr_value.Get());
1021 }
1022 }
1023 public class Context : System.Text.Parsing.Context
1024 {
1025 public Context() : context(), value(), fromtype(), fromval(), fromptrType(), fromptr()
1026 {
1027 }
1028 public cmsx.intermediate.Context* context;
1029 public Instruction* value;
1030 public Type* fromtype;
1031 public Value* fromval;
1032 public Type* fromptrType;
1033 public Value* fromptr;
1034 }
1035 }
1036
1037 public class ArgInstructionRule : System.Text.Parsing.RuleParser
1038 {
1039 public ArgInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
1040 {
1041 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
1042 SetValueTypeName(ToUtf32("Instruction*"));
1043 }
1044 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1045 {
1046 parsingData->PushContext(Id(), new Context());
1047 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1048 UniquePtr<Object> context_value = stack.Pop();
1049 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
1050 }
1051 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1052 {
1053 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1054 if (matched)
1055 {
1056 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
1057 }
1058 parsingData->PopContext(Id());
1059 }
1060 public override void Link()
1061 {
1062 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
1063 a0ActionParser->SetAction(A0Action);
1064 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
1065 typeNonterminalParser->SetPre(Pretype);
1066 typeNonterminalParser->SetPost(Posttype);
1067 NonterminalParser* argNonterminalParser = GetNonterminal(ToUtf32("arg"));
1068 argNonterminalParser->SetPre(Prearg);
1069 argNonterminalParser->SetPost(Postarg);
1070 }
1071 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1072 {
1073 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1074 context->value = new ArgInstruction(context->fromarg, span.lineNumber);
1075 }
1076 public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1077 {
1078 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1079 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
1080 }
1081 public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1082 {
1083 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1084 if (matched)
1085 {
1086 UniquePtr<Object> fromtype_value = stack.Pop();
1087 context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
1088 }
1089 }
1090 public void Prearg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1091 {
1092 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1093 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
1094 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->fromtype)));
1095 }
1096 public void Postarg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1097 {
1098 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1099 if (matched)
1100 {
1101 UniquePtr<Object> fromarg_value = stack.Pop();
1102 context->fromarg = *cast<ValueObject<Value*>*>(fromarg_value.Get());
1103 }
1104 }
1105 public class Context : System.Text.Parsing.Context
1106 {
1107 public Context() : context(), value(), fromtype(), fromarg()
1108 {
1109 }
1110 public cmsx.intermediate.Context* context;
1111 public Instruction* value;
1112 public Type* fromtype;
1113 public Value* fromarg;
1114 }
1115 }
1116
1117 public class JumpInstructionRule : System.Text.Parsing.RuleParser
1118 {
1119 public JumpInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
1120 {
1121 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
1122 SetValueTypeName(ToUtf32("Instruction*"));
1123 }
1124 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1125 {
1126 parsingData->PushContext(Id(), new Context());
1127 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1128 UniquePtr<Object> context_value = stack.Pop();
1129 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
1130 }
1131 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1132 {
1133 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1134 if (matched)
1135 {
1136 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
1137 }
1138 parsingData->PopContext(Id());
1139 }
1140 public override void Link()
1141 {
1142 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
1143 a0ActionParser->SetAction(A0Action);
1144 NonterminalParser* targetNonterminalParser = GetNonterminal(ToUtf32("target"));
1145 targetNonterminalParser->SetPost(Posttarget);
1146 }
1147 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1148 {
1149 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1150 context->value = new JumpInstruction(context->fromtarget, span.lineNumber);
1151 }
1152 public void Posttarget(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1153 {
1154 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1155 if (matched)
1156 {
1157 UniquePtr<Object> fromtarget_value = stack.Pop();
1158 context->fromtarget = *cast<ValueObject<uint>*>(fromtarget_value.Get());
1159 }
1160 }
1161 public class Context : System.Text.Parsing.Context
1162 {
1163 public Context() : context(), value(), fromtarget()
1164 {
1165 }
1166 public cmsx.intermediate.Context* context;
1167 public Instruction* value;
1168 public uint fromtarget;
1169 }
1170 }
1171
1172 public class BranchInstructionRule : System.Text.Parsing.RuleParser
1173 {
1174 public BranchInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
1175 {
1176 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
1177 SetValueTypeName(ToUtf32("Instruction*"));
1178 }
1179 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1180 {
1181 parsingData->PushContext(Id(), new Context());
1182 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1183 UniquePtr<Object> context_value = stack.Pop();
1184 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
1185 }
1186 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1187 {
1188 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1189 if (matched)
1190 {
1191 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
1192 }
1193 parsingData->PopContext(Id());
1194 }
1195 public override void Link()
1196 {
1197 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
1198 a0ActionParser->SetAction(A0Action);
1199 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
1200 typeNonterminalParser->SetPre(Pretype);
1201 typeNonterminalParser->SetPost(Posttype);
1202 NonterminalParser* condNonterminalParser = GetNonterminal(ToUtf32("cond"));
1203 condNonterminalParser->SetPre(Precond);
1204 condNonterminalParser->SetPost(Postcond);
1205 NonterminalParser* trueTargetNonterminalParser = GetNonterminal(ToUtf32("trueTarget"));
1206 trueTargetNonterminalParser->SetPost(PosttrueTarget);
1207 NonterminalParser* falseTargetNonterminalParser = GetNonterminal(ToUtf32("falseTarget"));
1208 falseTargetNonterminalParser->SetPost(PostfalseTarget);
1209 }
1210 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1211 {
1212 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1213 context->value = new BranchInstruction(context->fromcond, context->fromtrueTarget, context->fromfalseTarget, span.lineNumber);
1214 }
1215 public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1216 {
1217 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1218 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
1219 }
1220 public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1221 {
1222 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1223 if (matched)
1224 {
1225 UniquePtr<Object> fromtype_value = stack.Pop();
1226 context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
1227 }
1228 }
1229 public void Precond(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1230 {
1231 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1232 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
1233 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->fromtype)));
1234 }
1235 public void Postcond(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1236 {
1237 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1238 if (matched)
1239 {
1240 UniquePtr<Object> fromcond_value = stack.Pop();
1241 context->fromcond = *cast<ValueObject<Value*>*>(fromcond_value.Get());
1242 }
1243 }
1244 public void PosttrueTarget(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1245 {
1246 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1247 if (matched)
1248 {
1249 UniquePtr<Object> fromtrueTarget_value = stack.Pop();
1250 context->fromtrueTarget = *cast<ValueObject<uint>*>(fromtrueTarget_value.Get());
1251 }
1252 }
1253 public void PostfalseTarget(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1254 {
1255 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1256 if (matched)
1257 {
1258 UniquePtr<Object> fromfalseTarget_value = stack.Pop();
1259 context->fromfalseTarget = *cast<ValueObject<uint>*>(fromfalseTarget_value.Get());
1260 }
1261 }
1262 public class Context : System.Text.Parsing.Context
1263 {
1264 public Context() : context(), value(), fromtype(), fromcond(), fromtrueTarget(), fromfalseTarget()
1265 {
1266 }
1267 public cmsx.intermediate.Context* context;
1268 public Instruction* value;
1269 public Type* fromtype;
1270 public Value* fromcond;
1271 public uint fromtrueTarget;
1272 public uint fromfalseTarget;
1273 }
1274 }
1275
1276 public class ProcedureCallInstructionRule : System.Text.Parsing.RuleParser
1277 {
1278 public ProcedureCallInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
1279 {
1280 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
1281 SetValueTypeName(ToUtf32("Instruction*"));
1282 }
1283 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1284 {
1285 parsingData->PushContext(Id(), new Context());
1286 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1287 UniquePtr<Object> context_value = stack.Pop();
1288 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
1289 }
1290 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1291 {
1292 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1293 if (matched)
1294 {
1295 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
1296 }
1297 parsingData->PopContext(Id());
1298 }
1299 public override void Link()
1300 {
1301 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
1302 a0ActionParser->SetAction(A0Action);
1303 NonterminalParser* functionTypeNonterminalParser = GetNonterminal(ToUtf32("functionType"));
1304 functionTypeNonterminalParser->SetPre(PrefunctionType);
1305 functionTypeNonterminalParser->SetPost(PostfunctionType);
1306 NonterminalParser* calleeNonterminalParser = GetNonterminal(ToUtf32("callee"));
1307 calleeNonterminalParser->SetPre(Precallee);
1308 calleeNonterminalParser->SetPost(Postcallee);
1309 }
1310 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1311 {
1312 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1313 context->value = new ProcedureCallInstruction(context->fromcallee, span.lineNumber);
1314 }
1315 public void PrefunctionType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1316 {
1317 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1318 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
1319 }
1320 public void PostfunctionType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1321 {
1322 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1323 if (matched)
1324 {
1325 UniquePtr<Object> fromfunctionType_value = stack.Pop();
1326 context->fromfunctionType = *cast<ValueObject<Type*>*>(fromfunctionType_value.Get());
1327 }
1328 }
1329 public void Precallee(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1330 {
1331 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1332 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
1333 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->fromfunctionType)));
1334 }
1335 public void Postcallee(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1336 {
1337 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1338 if (matched)
1339 {
1340 UniquePtr<Object> fromcallee_value = stack.Pop();
1341 context->fromcallee = *cast<ValueObject<Value*>*>(fromcallee_value.Get());
1342 }
1343 }
1344 public class Context : System.Text.Parsing.Context
1345 {
1346 public Context() : context(), value(), fromfunctionType(), fromcallee()
1347 {
1348 }
1349 public cmsx.intermediate.Context* context;
1350 public Instruction* value;
1351 public Type* fromfunctionType;
1352 public Value* fromcallee;
1353 }
1354 }
1355
1356 public class RetInstructionRule : System.Text.Parsing.RuleParser
1357 {
1358 public RetInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
1359 {
1360 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
1361 SetValueTypeName(ToUtf32("Instruction*"));
1362 }
1363 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1364 {
1365 parsingData->PushContext(Id(), new Context());
1366 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1367 UniquePtr<Object> context_value = stack.Pop();
1368 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
1369 }
1370 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1371 {
1372 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1373 if (matched)
1374 {
1375 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
1376 }
1377 parsingData->PopContext(Id());
1378 }
1379 public override void Link()
1380 {
1381 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
1382 a0ActionParser->SetAction(A0Action);
1383 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
1384 a1ActionParser->SetAction(A1Action);
1385 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
1386 typeNonterminalParser->SetPre(Pretype);
1387 typeNonterminalParser->SetPost(Posttype);
1388 NonterminalParser* valNonterminalParser = GetNonterminal(ToUtf32("val"));
1389 valNonterminalParser->SetPre(Preval);
1390 valNonterminalParser->SetPost(Postval);
1391 }
1392 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1393 {
1394 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1395 context->value = new RetInstruction(null, span.lineNumber);
1396 }
1397 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1398 {
1399 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1400 context->value = new RetInstruction(context->fromval, span.lineNumber);
1401 }
1402 public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1403 {
1404 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1405 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
1406 }
1407 public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1408 {
1409 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1410 if (matched)
1411 {
1412 UniquePtr<Object> fromtype_value = stack.Pop();
1413 context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
1414 }
1415 }
1416 public void Preval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1417 {
1418 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1419 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
1420 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->fromtype)));
1421 }
1422 public void Postval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1423 {
1424 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1425 if (matched)
1426 {
1427 UniquePtr<Object> fromval_value = stack.Pop();
1428 context->fromval = *cast<ValueObject<Value*>*>(fromval_value.Get());
1429 }
1430 }
1431 public class Context : System.Text.Parsing.Context
1432 {
1433 public Context() : context(), value(), fromtype(), fromval()
1434 {
1435 }
1436 public cmsx.intermediate.Context* context;
1437 public Instruction* value;
1438 public Type* fromtype;
1439 public Value* fromval;
1440 }
1441 }
1442
1443 public class SwitchInstructionRule : System.Text.Parsing.RuleParser
1444 {
1445 public SwitchInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
1446 {
1447 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
1448 SetValueTypeName(ToUtf32("SwitchInstruction*"));
1449 }
1450 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1451 {
1452 parsingData->PushContext(Id(), new Context());
1453 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1454 UniquePtr<Object> context_value = stack.Pop();
1455 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
1456 }
1457 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1458 {
1459 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1460 if (matched)
1461 {
1462 stack.Push(UniquePtr<Object>(new ValueObject<SwitchInstruction*>(context->value)));
1463 }
1464 parsingData->PopContext(Id());
1465 }
1466 public override void Link()
1467 {
1468 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
1469 a0ActionParser->SetAction(A0Action);
1470 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
1471 a1ActionParser->SetAction(A1Action);
1472 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
1473 typeNonterminalParser->SetPre(Pretype);
1474 typeNonterminalParser->SetPost(Posttype);
1475 NonterminalParser* condNonterminalParser = GetNonterminal(ToUtf32("cond"));
1476 condNonterminalParser->SetPre(Precond);
1477 condNonterminalParser->SetPost(Postcond);
1478 NonterminalParser* defaultTargetNonterminalParser = GetNonterminal(ToUtf32("defaultTarget"));
1479 defaultTargetNonterminalParser->SetPost(PostdefaultTarget);
1480 NonterminalParser* caseTypeNonterminalParser = GetNonterminal(ToUtf32("caseType"));
1481 caseTypeNonterminalParser->SetPre(PrecaseType);
1482 caseTypeNonterminalParser->SetPost(PostcaseType);
1483 NonterminalParser* caseValueNonterminalParser = GetNonterminal(ToUtf32("caseValue"));
1484 caseValueNonterminalParser->SetPre(PrecaseValue);
1485 caseValueNonterminalParser->SetPost(PostcaseValue);
1486 NonterminalParser* caseTargetNonterminalParser = GetNonterminal(ToUtf32("caseTarget"));
1487 caseTargetNonterminalParser->SetPost(PostcaseTarget);
1488 }
1489 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1490 {
1491 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1492 context->value = new SwitchInstruction(context->fromcond, context->fromdefaultTarget, span.lineNumber);
1493 }
1494 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1495 {
1496 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1497 context->value->AddCase(context->fromcaseValue, context->fromcaseTarget);
1498 }
1499 public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1500 {
1501 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1502 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
1503 }
1504 public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1505 {
1506 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1507 if (matched)
1508 {
1509 UniquePtr<Object> fromtype_value = stack.Pop();
1510 context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
1511 }
1512 }
1513 public void Precond(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1514 {
1515 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1516 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
1517 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->fromtype)));
1518 }
1519 public void Postcond(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1520 {
1521 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1522 if (matched)
1523 {
1524 UniquePtr<Object> fromcond_value = stack.Pop();
1525 context->fromcond = *cast<ValueObject<Value*>*>(fromcond_value.Get());
1526 }
1527 }
1528 public void PostdefaultTarget(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1529 {
1530 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1531 if (matched)
1532 {
1533 UniquePtr<Object> fromdefaultTarget_value = stack.Pop();
1534 context->fromdefaultTarget = *cast<ValueObject<uint>*>(fromdefaultTarget_value.Get());
1535 }
1536 }
1537 public void PrecaseType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1538 {
1539 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1540 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
1541 }
1542 public void PostcaseType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1543 {
1544 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1545 if (matched)
1546 {
1547 UniquePtr<Object> fromcaseType_value = stack.Pop();
1548 context->fromcaseType = *cast<ValueObject<Type*>*>(fromcaseType_value.Get());
1549 }
1550 }
1551 public void PrecaseValue(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1552 {
1553 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1554 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
1555 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->fromcaseType)));
1556 }
1557 public void PostcaseValue(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1558 {
1559 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1560 if (matched)
1561 {
1562 UniquePtr<Object> fromcaseValue_value = stack.Pop();
1563 context->fromcaseValue = *cast<ValueObject<Value*>*>(fromcaseValue_value.Get());
1564 }
1565 }
1566 public void PostcaseTarget(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1567 {
1568 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1569 if (matched)
1570 {
1571 UniquePtr<Object> fromcaseTarget_value = stack.Pop();
1572 context->fromcaseTarget = *cast<ValueObject<uint>*>(fromcaseTarget_value.Get());
1573 }
1574 }
1575 public class Context : System.Text.Parsing.Context
1576 {
1577 public Context() : context(), value(), fromtype(), fromcond(), fromdefaultTarget(), fromcaseType(), fromcaseValue(), fromcaseTarget()
1578 {
1579 }
1580 public cmsx.intermediate.Context* context;
1581 public SwitchInstruction* value;
1582 public Type* fromtype;
1583 public Value* fromcond;
1584 public uint fromdefaultTarget;
1585 public Type* fromcaseType;
1586 public Value* fromcaseValue;
1587 public uint fromcaseTarget;
1588 }
1589 }
1590
1591 public class NoOperationInstructionRule : System.Text.Parsing.RuleParser
1592 {
1593 public NoOperationInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
1594 {
1595 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
1596 SetValueTypeName(ToUtf32("Instruction*"));
1597 }
1598 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1599 {
1600 parsingData->PushContext(Id(), new Context());
1601 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1602 UniquePtr<Object> context_value = stack.Pop();
1603 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
1604 }
1605 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1606 {
1607 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1608 if (matched)
1609 {
1610 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
1611 }
1612 parsingData->PopContext(Id());
1613 }
1614 public override void Link()
1615 {
1616 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
1617 a0ActionParser->SetAction(A0Action);
1618 }
1619 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1620 {
1621 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1622 context->value = new NoOperationInstruction(span.lineNumber);
1623 }
1624 public class Context : System.Text.Parsing.Context
1625 {
1626 public Context() : context(), value()
1627 {
1628 }
1629 public cmsx.intermediate.Context* context;
1630 public Instruction* value;
1631 }
1632 }
1633
1634 public class SaveInstructionRule : System.Text.Parsing.RuleParser
1635 {
1636 public SaveInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
1637 {
1638 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
1639 SetValueTypeName(ToUtf32("Instruction*"));
1640 }
1641 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1642 {
1643 parsingData->PushContext(Id(), new Context());
1644 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1645 UniquePtr<Object> context_value = stack.Pop();
1646 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
1647 }
1648 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1649 {
1650 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1651 if (matched)
1652 {
1653 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
1654 }
1655 parsingData->PopContext(Id());
1656 }
1657 public override void Link()
1658 {
1659 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
1660 a0ActionParser->SetAction(A0Action);
1661 }
1662 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1663 {
1664 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1665 context->value = new SaveInstruction(span.lineNumber);
1666 }
1667 public class Context : System.Text.Parsing.Context
1668 {
1669 public Context() : context(), value()
1670 {
1671 }
1672 public cmsx.intermediate.Context* context;
1673 public Instruction* value;
1674 }
1675 }
1676
1677 public class ValueInstructionRule : System.Text.Parsing.RuleParser
1678 {
1679 public ValueInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
1680 {
1681 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
1682 SetValueTypeName(ToUtf32("Instruction*"));
1683 }
1684 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1685 {
1686 parsingData->PushContext(Id(), new Context());
1687 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1688 UniquePtr<Object> context_value = stack.Pop();
1689 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
1690 }
1691 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1692 {
1693 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1694 if (matched)
1695 {
1696 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
1697 }
1698 parsingData->PopContext(Id());
1699 }
1700 public override void Link()
1701 {
1702 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
1703 a0ActionParser->SetAction(A0Action);
1704 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
1705 typeNonterminalParser->SetPre(Pretype);
1706 typeNonterminalParser->SetPost(Posttype);
1707 NonterminalParser* resultNonterminalParser = GetNonterminal(ToUtf32("result"));
1708 resultNonterminalParser->SetPre(Preresult);
1709 resultNonterminalParser->SetPost(Postresult);
1710 NonterminalParser* operationNonterminalParser = GetNonterminal(ToUtf32("Operation"));
1711 operationNonterminalParser->SetPre(PreOperation);
1712 operationNonterminalParser->SetPost(PostOperation);
1713 }
1714 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1715 {
1716 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1717 context->value = context->fromOperation;
1718 }
1719 public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1720 {
1721 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1722 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
1723 }
1724 public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1725 {
1726 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1727 if (matched)
1728 {
1729 UniquePtr<Object> fromtype_value = stack.Pop();
1730 context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
1731 }
1732 }
1733 public void Preresult(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1734 {
1735 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1736 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
1737 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->fromtype)));
1738 }
1739 public void Postresult(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1740 {
1741 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1742 if (matched)
1743 {
1744 UniquePtr<Object> fromresult_value = stack.Pop();
1745 context->fromresult = *cast<ValueObject<Value*>*>(fromresult_value.Get());
1746 }
1747 }
1748 public void PreOperation(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1749 {
1750 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1751 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
1752 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->fromresult)));
1753 }
1754 public void PostOperation(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1755 {
1756 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1757 if (matched)
1758 {
1759 UniquePtr<Object> fromOperation_value = stack.Pop();
1760 context->fromOperation = *cast<ValueObject<Instruction*>*>(fromOperation_value.Get());
1761 }
1762 }
1763 public class Context : System.Text.Parsing.Context
1764 {
1765 public Context() : context(), value(), fromtype(), fromresult(), fromOperation()
1766 {
1767 }
1768 public cmsx.intermediate.Context* context;
1769 public Instruction* value;
1770 public Type* fromtype;
1771 public Value* fromresult;
1772 public Instruction* fromOperation;
1773 }
1774 }
1775
1776 public class OperationRule : System.Text.Parsing.RuleParser
1777 {
1778 public OperationRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
1779 {
1780 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
1781 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
1782 SetValueTypeName(ToUtf32("Instruction*"));
1783 }
1784 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1785 {
1786 parsingData->PushContext(Id(), new Context());
1787 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1788 UniquePtr<Object> result_value = stack.Pop();
1789 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
1790 UniquePtr<Object> context_value = stack.Pop();
1791 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
1792 }
1793 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1794 {
1795 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1796 if (matched)
1797 {
1798 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
1799 }
1800 parsingData->PopContext(Id());
1801 }
1802 public override void Link()
1803 {
1804 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
1805 a0ActionParser->SetAction(A0Action);
1806 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
1807 a1ActionParser->SetAction(A1Action);
1808 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
1809 a2ActionParser->SetAction(A2Action);
1810 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
1811 a3ActionParser->SetAction(A3Action);
1812 ActionParser* a4ActionParser = GetAction(ToUtf32("A4"));
1813 a4ActionParser->SetAction(A4Action);
1814 ActionParser* a5ActionParser = GetAction(ToUtf32("A5"));
1815 a5ActionParser->SetAction(A5Action);
1816 ActionParser* a6ActionParser = GetAction(ToUtf32("A6"));
1817 a6ActionParser->SetAction(A6Action);
1818 ActionParser* a7ActionParser = GetAction(ToUtf32("A7"));
1819 a7ActionParser->SetAction(A7Action);
1820 ActionParser* a8ActionParser = GetAction(ToUtf32("A8"));
1821 a8ActionParser->SetAction(A8Action);
1822 ActionParser* a9ActionParser = GetAction(ToUtf32("A9"));
1823 a9ActionParser->SetAction(A9Action);
1824 NonterminalParser* unaryInstructionNonterminalParser = GetNonterminal(ToUtf32("UnaryInstruction"));
1825 unaryInstructionNonterminalParser->SetPre(PreUnaryInstruction);
1826 unaryInstructionNonterminalParser->SetPost(PostUnaryInstruction);
1827 NonterminalParser* binaryInstructionNonterminalParser = GetNonterminal(ToUtf32("BinaryInstruction"));
1828 binaryInstructionNonterminalParser->SetPre(PreBinaryInstruction);
1829 binaryInstructionNonterminalParser->SetPost(PostBinaryInstruction);
1830 NonterminalParser* paramInstructionNonterminalParser = GetNonterminal(ToUtf32("ParamInstruction"));
1831 paramInstructionNonterminalParser->SetPre(PreParamInstruction);
1832 paramInstructionNonterminalParser->SetPost(PostParamInstruction);
1833 NonterminalParser* localInstructionNonterminalParser = GetNonterminal(ToUtf32("LocalInstruction"));
1834 localInstructionNonterminalParser->SetPre(PreLocalInstruction);
1835 localInstructionNonterminalParser->SetPost(PostLocalInstruction);
1836 NonterminalParser* loadInstructionNonterminalParser = GetNonterminal(ToUtf32("LoadInstruction"));
1837 loadInstructionNonterminalParser->SetPre(PreLoadInstruction);
1838 loadInstructionNonterminalParser->SetPost(PostLoadInstruction);
1839 NonterminalParser* elemAddrInstructionNonterminalParser = GetNonterminal(ToUtf32("ElemAddrInstruction"));
1840 elemAddrInstructionNonterminalParser->SetPre(PreElemAddrInstruction);
1841 elemAddrInstructionNonterminalParser->SetPost(PostElemAddrInstruction);
1842 NonterminalParser* ptrOffsetInstructionNonterminalParser = GetNonterminal(ToUtf32("PtrOffsetInstruction"));
1843 ptrOffsetInstructionNonterminalParser->SetPre(PrePtrOffsetInstruction);
1844 ptrOffsetInstructionNonterminalParser->SetPost(PostPtrOffsetInstruction);
1845 NonterminalParser* ptrDiffInstructionNonterminalParser = GetNonterminal(ToUtf32("PtrDiffInstruction"));
1846 ptrDiffInstructionNonterminalParser->SetPre(PrePtrDiffInstruction);
1847 ptrDiffInstructionNonterminalParser->SetPost(PostPtrDiffInstruction);
1848 NonterminalParser* functionCallInstructionNonterminalParser = GetNonterminal(ToUtf32("FunctionCallInstruction"));
1849 functionCallInstructionNonterminalParser->SetPre(PreFunctionCallInstruction);
1850 functionCallInstructionNonterminalParser->SetPost(PostFunctionCallInstruction);
1851 NonterminalParser* trapInstructionNonterminalParser = GetNonterminal(ToUtf32("TrapInstruction"));
1852 trapInstructionNonterminalParser->SetPre(PreTrapInstruction);
1853 trapInstructionNonterminalParser->SetPost(PostTrapInstruction);
1854 }
1855 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1856 {
1857 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1858 context->value = context->fromUnaryInstruction;
1859 }
1860 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1861 {
1862 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1863 context->value = context->fromBinaryInstruction;
1864 }
1865 public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1866 {
1867 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1868 context->value = context->fromParamInstruction;
1869 }
1870 public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1871 {
1872 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1873 context->value = context->fromLocalInstruction;
1874 }
1875 public void A4Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1876 {
1877 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1878 context->value = context->fromLoadInstruction;
1879 }
1880 public void A5Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1881 {
1882 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1883 context->value = context->fromElemAddrInstruction;
1884 }
1885 public void A6Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1886 {
1887 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1888 context->value = context->fromPtrOffsetInstruction;
1889 }
1890 public void A7Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1891 {
1892 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1893 context->value = context->fromPtrDiffInstruction;
1894 }
1895 public void A8Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1896 {
1897 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1898 context->value = context->fromFunctionCallInstruction;
1899 }
1900 public void A9Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1901 {
1902 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1903 context->value = context->fromTrapInstruction;
1904 }
1905 public void PreUnaryInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1906 {
1907 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1908 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
1909 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
1910 }
1911 public void PostUnaryInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1912 {
1913 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1914 if (matched)
1915 {
1916 UniquePtr<Object> fromUnaryInstruction_value = stack.Pop();
1917 context->fromUnaryInstruction = *cast<ValueObject<Instruction*>*>(fromUnaryInstruction_value.Get());
1918 }
1919 }
1920 public void PreBinaryInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1921 {
1922 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1923 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
1924 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
1925 }
1926 public void PostBinaryInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1927 {
1928 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1929 if (matched)
1930 {
1931 UniquePtr<Object> fromBinaryInstruction_value = stack.Pop();
1932 context->fromBinaryInstruction = *cast<ValueObject<Instruction*>*>(fromBinaryInstruction_value.Get());
1933 }
1934 }
1935 public void PreParamInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1936 {
1937 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1938 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
1939 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
1940 }
1941 public void PostParamInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1942 {
1943 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1944 if (matched)
1945 {
1946 UniquePtr<Object> fromParamInstruction_value = stack.Pop();
1947 context->fromParamInstruction = *cast<ValueObject<Instruction*>*>(fromParamInstruction_value.Get());
1948 }
1949 }
1950 public void PreLocalInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1951 {
1952 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1953 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
1954 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
1955 }
1956 public void PostLocalInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1957 {
1958 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1959 if (matched)
1960 {
1961 UniquePtr<Object> fromLocalInstruction_value = stack.Pop();
1962 context->fromLocalInstruction = *cast<ValueObject<Instruction*>*>(fromLocalInstruction_value.Get());
1963 }
1964 }
1965 public void PreLoadInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1966 {
1967 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1968 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
1969 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
1970 }
1971 public void PostLoadInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1972 {
1973 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1974 if (matched)
1975 {
1976 UniquePtr<Object> fromLoadInstruction_value = stack.Pop();
1977 context->fromLoadInstruction = *cast<ValueObject<Instruction*>*>(fromLoadInstruction_value.Get());
1978 }
1979 }
1980 public void PreElemAddrInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1981 {
1982 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1983 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
1984 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
1985 }
1986 public void PostElemAddrInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1987 {
1988 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1989 if (matched)
1990 {
1991 UniquePtr<Object> fromElemAddrInstruction_value = stack.Pop();
1992 context->fromElemAddrInstruction = *cast<ValueObject<Instruction*>*>(fromElemAddrInstruction_value.Get());
1993 }
1994 }
1995 public void PrePtrOffsetInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1996 {
1997 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1998 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
1999 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
2000 }
2001 public void PostPtrOffsetInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2002 {
2003 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2004 if (matched)
2005 {
2006 UniquePtr<Object> fromPtrOffsetInstruction_value = stack.Pop();
2007 context->fromPtrOffsetInstruction = *cast<ValueObject<Instruction*>*>(fromPtrOffsetInstruction_value.Get());
2008 }
2009 }
2010 public void PrePtrDiffInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2011 {
2012 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2013 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
2014 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
2015 }
2016 public void PostPtrDiffInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2017 {
2018 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2019 if (matched)
2020 {
2021 UniquePtr<Object> fromPtrDiffInstruction_value = stack.Pop();
2022 context->fromPtrDiffInstruction = *cast<ValueObject<Instruction*>*>(fromPtrDiffInstruction_value.Get());
2023 }
2024 }
2025 public void PreFunctionCallInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2026 {
2027 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2028 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
2029 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
2030 }
2031 public void PostFunctionCallInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2032 {
2033 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2034 if (matched)
2035 {
2036 UniquePtr<Object> fromFunctionCallInstruction_value = stack.Pop();
2037 context->fromFunctionCallInstruction = *cast<ValueObject<Instruction*>*>(fromFunctionCallInstruction_value.Get());
2038 }
2039 }
2040 public void PreTrapInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2041 {
2042 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2043 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
2044 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
2045 }
2046 public void PostTrapInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2047 {
2048 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2049 if (matched)
2050 {
2051 UniquePtr<Object> fromTrapInstruction_value = stack.Pop();
2052 context->fromTrapInstruction = *cast<ValueObject<Instruction*>*>(fromTrapInstruction_value.Get());
2053 }
2054 }
2055 public class Context : System.Text.Parsing.Context
2056 {
2057 public Context() : context(), result(), value(), fromUnaryInstruction(), fromBinaryInstruction(), fromParamInstruction(), fromLocalInstruction(), fromLoadInstruction(), fromElemAddrInstruction(), fromPtrOffsetInstruction(), fromPtrDiffInstruction(), fromFunctionCallInstruction(), fromTrapInstruction()
2058 {
2059 }
2060 public cmsx.intermediate.Context* context;
2061 public Value* result;
2062 public Instruction* value;
2063 public Instruction* fromUnaryInstruction;
2064 public Instruction* fromBinaryInstruction;
2065 public Instruction* fromParamInstruction;
2066 public Instruction* fromLocalInstruction;
2067 public Instruction* fromLoadInstruction;
2068 public Instruction* fromElemAddrInstruction;
2069 public Instruction* fromPtrOffsetInstruction;
2070 public Instruction* fromPtrDiffInstruction;
2071 public Instruction* fromFunctionCallInstruction;
2072 public Instruction* fromTrapInstruction;
2073 }
2074 }
2075
2076 public class UnaryInstructionRule : System.Text.Parsing.RuleParser
2077 {
2078 public UnaryInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
2079 {
2080 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
2081 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
2082 SetValueTypeName(ToUtf32("Instruction*"));
2083 }
2084 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2085 {
2086 parsingData->PushContext(Id(), new Context());
2087 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2088 UniquePtr<Object> result_value = stack.Pop();
2089 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
2090 UniquePtr<Object> context_value = stack.Pop();
2091 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
2092 }
2093 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2094 {
2095 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2096 if (matched)
2097 {
2098 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
2099 }
2100 parsingData->PopContext(Id());
2101 }
2102 public override void Link()
2103 {
2104 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
2105 a0ActionParser->SetAction(A0Action);
2106 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
2107 a1ActionParser->SetAction(A1Action);
2108 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
2109 a2ActionParser->SetAction(A2Action);
2110 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
2111 a3ActionParser->SetAction(A3Action);
2112 ActionParser* a4ActionParser = GetAction(ToUtf32("A4"));
2113 a4ActionParser->SetAction(A4Action);
2114 ActionParser* a5ActionParser = GetAction(ToUtf32("A5"));
2115 a5ActionParser->SetAction(A5Action);
2116 ActionParser* a6ActionParser = GetAction(ToUtf32("A6"));
2117 a6ActionParser->SetAction(A6Action);
2118 ActionParser* a7ActionParser = GetAction(ToUtf32("A7"));
2119 a7ActionParser->SetAction(A7Action);
2120 ActionParser* a8ActionParser = GetAction(ToUtf32("A8"));
2121 a8ActionParser->SetAction(A8Action);
2122 ActionParser* a9ActionParser = GetAction(ToUtf32("A9"));
2123 a9ActionParser->SetAction(A9Action);
2124 NonterminalParser* notInstructionNonterminalParser = GetNonterminal(ToUtf32("NotInstruction"));
2125 notInstructionNonterminalParser->SetPre(PreNotInstruction);
2126 notInstructionNonterminalParser->SetPost(PostNotInstruction);
2127 NonterminalParser* negInstructionNonterminalParser = GetNonterminal(ToUtf32("NegInstruction"));
2128 negInstructionNonterminalParser->SetPre(PreNegInstruction);
2129 negInstructionNonterminalParser->SetPost(PostNegInstruction);
2130 NonterminalParser* signExtendInstructionNonterminalParser = GetNonterminal(ToUtf32("SignExtendInstruction"));
2131 signExtendInstructionNonterminalParser->SetPre(PreSignExtendInstruction);
2132 signExtendInstructionNonterminalParser->SetPost(PostSignExtendInstruction);
2133 NonterminalParser* zeroExtendInstructionNonterminalParser = GetNonterminal(ToUtf32("ZeroExtendInstruction"));
2134 zeroExtendInstructionNonterminalParser->SetPre(PreZeroExtendInstruction);
2135 zeroExtendInstructionNonterminalParser->SetPost(PostZeroExtendInstruction);
2136 NonterminalParser* truncateInstructionNonterminalParser = GetNonterminal(ToUtf32("TruncateInstruction"));
2137 truncateInstructionNonterminalParser->SetPre(PreTruncateInstruction);
2138 truncateInstructionNonterminalParser->SetPost(PostTruncateInstruction);
2139 NonterminalParser* bitCastInstructionNonterminalParser = GetNonterminal(ToUtf32("BitCastInstruction"));
2140 bitCastInstructionNonterminalParser->SetPre(PreBitCastInstruction);
2141 bitCastInstructionNonterminalParser->SetPost(PostBitCastInstruction);
2142 NonterminalParser* intToFloatInstructionNonterminalParser = GetNonterminal(ToUtf32("IntToFloatInstruction"));
2143 intToFloatInstructionNonterminalParser->SetPre(PreIntToFloatInstruction);
2144 intToFloatInstructionNonterminalParser->SetPost(PostIntToFloatInstruction);
2145 NonterminalParser* floatToIntInstructionNonterminalParser = GetNonterminal(ToUtf32("FloatToIntInstruction"));
2146 floatToIntInstructionNonterminalParser->SetPre(PreFloatToIntInstruction);
2147 floatToIntInstructionNonterminalParser->SetPost(PostFloatToIntInstruction);
2148 NonterminalParser* intToPtrInstructionNonterminalParser = GetNonterminal(ToUtf32("IntToPtrInstruction"));
2149 intToPtrInstructionNonterminalParser->SetPre(PreIntToPtrInstruction);
2150 intToPtrInstructionNonterminalParser->SetPost(PostIntToPtrInstruction);
2151 NonterminalParser* ptrToIntInstructionNonterminalParser = GetNonterminal(ToUtf32("PtrToIntInstruction"));
2152 ptrToIntInstructionNonterminalParser->SetPre(PrePtrToIntInstruction);
2153 ptrToIntInstructionNonterminalParser->SetPost(PostPtrToIntInstruction);
2154 }
2155 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2156 {
2157 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2158 context->value = context->fromNotInstruction;
2159 }
2160 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2161 {
2162 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2163 context->value = context->fromNegInstruction;
2164 }
2165 public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2166 {
2167 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2168 context->value = context->fromSignExtendInstruction;
2169 }
2170 public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2171 {
2172 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2173 context->value = context->fromZeroExtendInstruction;
2174 }
2175 public void A4Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2176 {
2177 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2178 context->value = context->fromTruncateInstruction;
2179 }
2180 public void A5Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2181 {
2182 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2183 context->value = context->fromBitCastInstruction;
2184 }
2185 public void A6Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2186 {
2187 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2188 context->value = context->fromIntToFloatInstruction;
2189 }
2190 public void A7Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2191 {
2192 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2193 context->value = context->fromFloatToIntInstruction;
2194 }
2195 public void A8Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2196 {
2197 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2198 context->value = context->fromIntToPtrInstruction;
2199 }
2200 public void A9Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2201 {
2202 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2203 context->value = context->fromPtrToIntInstruction;
2204 }
2205 public void PreNotInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2206 {
2207 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2208 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
2209 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
2210 }
2211 public void PostNotInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2212 {
2213 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2214 if (matched)
2215 {
2216 UniquePtr<Object> fromNotInstruction_value = stack.Pop();
2217 context->fromNotInstruction = *cast<ValueObject<Instruction*>*>(fromNotInstruction_value.Get());
2218 }
2219 }
2220 public void PreNegInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2221 {
2222 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2223 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
2224 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
2225 }
2226 public void PostNegInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2227 {
2228 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2229 if (matched)
2230 {
2231 UniquePtr<Object> fromNegInstruction_value = stack.Pop();
2232 context->fromNegInstruction = *cast<ValueObject<Instruction*>*>(fromNegInstruction_value.Get());
2233 }
2234 }
2235 public void PreSignExtendInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2236 {
2237 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2238 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
2239 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
2240 }
2241 public void PostSignExtendInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2242 {
2243 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2244 if (matched)
2245 {
2246 UniquePtr<Object> fromSignExtendInstruction_value = stack.Pop();
2247 context->fromSignExtendInstruction = *cast<ValueObject<Instruction*>*>(fromSignExtendInstruction_value.Get());
2248 }
2249 }
2250 public void PreZeroExtendInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2251 {
2252 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2253 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
2254 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
2255 }
2256 public void PostZeroExtendInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2257 {
2258 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2259 if (matched)
2260 {
2261 UniquePtr<Object> fromZeroExtendInstruction_value = stack.Pop();
2262 context->fromZeroExtendInstruction = *cast<ValueObject<Instruction*>*>(fromZeroExtendInstruction_value.Get());
2263 }
2264 }
2265 public void PreTruncateInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2266 {
2267 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2268 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
2269 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
2270 }
2271 public void PostTruncateInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2272 {
2273 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2274 if (matched)
2275 {
2276 UniquePtr<Object> fromTruncateInstruction_value = stack.Pop();
2277 context->fromTruncateInstruction = *cast<ValueObject<Instruction*>*>(fromTruncateInstruction_value.Get());
2278 }
2279 }
2280 public void PreBitCastInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2281 {
2282 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2283 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
2284 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
2285 }
2286 public void PostBitCastInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2287 {
2288 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2289 if (matched)
2290 {
2291 UniquePtr<Object> fromBitCastInstruction_value = stack.Pop();
2292 context->fromBitCastInstruction = *cast<ValueObject<Instruction*>*>(fromBitCastInstruction_value.Get());
2293 }
2294 }
2295 public void PreIntToFloatInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2296 {
2297 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2298 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
2299 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
2300 }
2301 public void PostIntToFloatInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2302 {
2303 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2304 if (matched)
2305 {
2306 UniquePtr<Object> fromIntToFloatInstruction_value = stack.Pop();
2307 context->fromIntToFloatInstruction = *cast<ValueObject<Instruction*>*>(fromIntToFloatInstruction_value.Get());
2308 }
2309 }
2310 public void PreFloatToIntInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2311 {
2312 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2313 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
2314 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
2315 }
2316 public void PostFloatToIntInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2317 {
2318 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2319 if (matched)
2320 {
2321 UniquePtr<Object> fromFloatToIntInstruction_value = stack.Pop();
2322 context->fromFloatToIntInstruction = *cast<ValueObject<Instruction*>*>(fromFloatToIntInstruction_value.Get());
2323 }
2324 }
2325 public void PreIntToPtrInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2326 {
2327 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2328 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
2329 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
2330 }
2331 public void PostIntToPtrInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2332 {
2333 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2334 if (matched)
2335 {
2336 UniquePtr<Object> fromIntToPtrInstruction_value = stack.Pop();
2337 context->fromIntToPtrInstruction = *cast<ValueObject<Instruction*>*>(fromIntToPtrInstruction_value.Get());
2338 }
2339 }
2340 public void PrePtrToIntInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2341 {
2342 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2343 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
2344 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
2345 }
2346 public void PostPtrToIntInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2347 {
2348 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2349 if (matched)
2350 {
2351 UniquePtr<Object> fromPtrToIntInstruction_value = stack.Pop();
2352 context->fromPtrToIntInstruction = *cast<ValueObject<Instruction*>*>(fromPtrToIntInstruction_value.Get());
2353 }
2354 }
2355 public class Context : System.Text.Parsing.Context
2356 {
2357 public Context() : context(), result(), value(), fromNotInstruction(), fromNegInstruction(), fromSignExtendInstruction(), fromZeroExtendInstruction(), fromTruncateInstruction(), fromBitCastInstruction(), fromIntToFloatInstruction(), fromFloatToIntInstruction(), fromIntToPtrInstruction(), fromPtrToIntInstruction()
2358 {
2359 }
2360 public cmsx.intermediate.Context* context;
2361 public Value* result;
2362 public Instruction* value;
2363 public Instruction* fromNotInstruction;
2364 public Instruction* fromNegInstruction;
2365 public Instruction* fromSignExtendInstruction;
2366 public Instruction* fromZeroExtendInstruction;
2367 public Instruction* fromTruncateInstruction;
2368 public Instruction* fromBitCastInstruction;
2369 public Instruction* fromIntToFloatInstruction;
2370 public Instruction* fromFloatToIntInstruction;
2371 public Instruction* fromIntToPtrInstruction;
2372 public Instruction* fromPtrToIntInstruction;
2373 }
2374 }
2375
2376 public class NotInstructionRule : System.Text.Parsing.RuleParser
2377 {
2378 public NotInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
2379 {
2380 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
2381 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
2382 SetValueTypeName(ToUtf32("Instruction*"));
2383 }
2384 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2385 {
2386 parsingData->PushContext(Id(), new Context());
2387 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2388 UniquePtr<Object> result_value = stack.Pop();
2389 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
2390 UniquePtr<Object> context_value = stack.Pop();
2391 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
2392 }
2393 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2394 {
2395 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2396 if (matched)
2397 {
2398 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
2399 }
2400 parsingData->PopContext(Id());
2401 }
2402 public override void Link()
2403 {
2404 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
2405 a0ActionParser->SetAction(A0Action);
2406 NonterminalParser* argNonterminalParser = GetNonterminal(ToUtf32("arg"));
2407 argNonterminalParser->SetPre(Prearg);
2408 argNonterminalParser->SetPost(Postarg);
2409 }
2410 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2411 {
2412 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2413 context->value = new NotInstruction(context->result, context->fromarg, span.lineNumber);
2414 }
2415 public void Prearg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2416 {
2417 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2418 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
2419 }
2420 public void Postarg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2421 {
2422 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2423 if (matched)
2424 {
2425 UniquePtr<Object> fromarg_value = stack.Pop();
2426 context->fromarg = *cast<ValueObject<Value*>*>(fromarg_value.Get());
2427 }
2428 }
2429 public class Context : System.Text.Parsing.Context
2430 {
2431 public Context() : context(), result(), value(), fromarg()
2432 {
2433 }
2434 public cmsx.intermediate.Context* context;
2435 public Value* result;
2436 public Instruction* value;
2437 public Value* fromarg;
2438 }
2439 }
2440
2441 public class NegInstructionRule : System.Text.Parsing.RuleParser
2442 {
2443 public NegInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
2444 {
2445 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
2446 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
2447 SetValueTypeName(ToUtf32("Instruction*"));
2448 }
2449 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2450 {
2451 parsingData->PushContext(Id(), new Context());
2452 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2453 UniquePtr<Object> result_value = stack.Pop();
2454 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
2455 UniquePtr<Object> context_value = stack.Pop();
2456 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
2457 }
2458 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2459 {
2460 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2461 if (matched)
2462 {
2463 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
2464 }
2465 parsingData->PopContext(Id());
2466 }
2467 public override void Link()
2468 {
2469 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
2470 a0ActionParser->SetAction(A0Action);
2471 NonterminalParser* argNonterminalParser = GetNonterminal(ToUtf32("arg"));
2472 argNonterminalParser->SetPre(Prearg);
2473 argNonterminalParser->SetPost(Postarg);
2474 }
2475 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2476 {
2477 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2478 context->value = new NegInstruction(context->result, context->fromarg, span.lineNumber);
2479 }
2480 public void Prearg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2481 {
2482 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2483 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
2484 }
2485 public void Postarg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2486 {
2487 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2488 if (matched)
2489 {
2490 UniquePtr<Object> fromarg_value = stack.Pop();
2491 context->fromarg = *cast<ValueObject<Value*>*>(fromarg_value.Get());
2492 }
2493 }
2494 public class Context : System.Text.Parsing.Context
2495 {
2496 public Context() : context(), result(), value(), fromarg()
2497 {
2498 }
2499 public cmsx.intermediate.Context* context;
2500 public Value* result;
2501 public Instruction* value;
2502 public Value* fromarg;
2503 }
2504 }
2505
2506 public class SignExtendInstructionRule : System.Text.Parsing.RuleParser
2507 {
2508 public SignExtendInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
2509 {
2510 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
2511 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
2512 SetValueTypeName(ToUtf32("Instruction*"));
2513 }
2514 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2515 {
2516 parsingData->PushContext(Id(), new Context());
2517 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2518 UniquePtr<Object> result_value = stack.Pop();
2519 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
2520 UniquePtr<Object> context_value = stack.Pop();
2521 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
2522 }
2523 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2524 {
2525 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2526 if (matched)
2527 {
2528 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
2529 }
2530 parsingData->PopContext(Id());
2531 }
2532 public override void Link()
2533 {
2534 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
2535 a0ActionParser->SetAction(A0Action);
2536 NonterminalParser* argNonterminalParser = GetNonterminal(ToUtf32("arg"));
2537 argNonterminalParser->SetPre(Prearg);
2538 argNonterminalParser->SetPost(Postarg);
2539 }
2540 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2541 {
2542 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2543 context->value = new SignExtendInstruction(context->result, context->fromarg, span.lineNumber);
2544 }
2545 public void Prearg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2546 {
2547 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2548 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
2549 }
2550 public void Postarg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2551 {
2552 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2553 if (matched)
2554 {
2555 UniquePtr<Object> fromarg_value = stack.Pop();
2556 context->fromarg = *cast<ValueObject<Value*>*>(fromarg_value.Get());
2557 }
2558 }
2559 public class Context : System.Text.Parsing.Context
2560 {
2561 public Context() : context(), result(), value(), fromarg()
2562 {
2563 }
2564 public cmsx.intermediate.Context* context;
2565 public Value* result;
2566 public Instruction* value;
2567 public Value* fromarg;
2568 }
2569 }
2570
2571 public class ZeroExtendInstructionRule : System.Text.Parsing.RuleParser
2572 {
2573 public ZeroExtendInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
2574 {
2575 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
2576 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
2577 SetValueTypeName(ToUtf32("Instruction*"));
2578 }
2579 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2580 {
2581 parsingData->PushContext(Id(), new Context());
2582 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2583 UniquePtr<Object> result_value = stack.Pop();
2584 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
2585 UniquePtr<Object> context_value = stack.Pop();
2586 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
2587 }
2588 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2589 {
2590 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2591 if (matched)
2592 {
2593 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
2594 }
2595 parsingData->PopContext(Id());
2596 }
2597 public override void Link()
2598 {
2599 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
2600 a0ActionParser->SetAction(A0Action);
2601 NonterminalParser* argNonterminalParser = GetNonterminal(ToUtf32("arg"));
2602 argNonterminalParser->SetPre(Prearg);
2603 argNonterminalParser->SetPost(Postarg);
2604 }
2605 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2606 {
2607 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2608 context->value = new ZeroExtendInstruction(context->result, context->fromarg, span.lineNumber);
2609 }
2610 public void Prearg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2611 {
2612 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2613 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
2614 }
2615 public void Postarg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2616 {
2617 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2618 if (matched)
2619 {
2620 UniquePtr<Object> fromarg_value = stack.Pop();
2621 context->fromarg = *cast<ValueObject<Value*>*>(fromarg_value.Get());
2622 }
2623 }
2624 public class Context : System.Text.Parsing.Context
2625 {
2626 public Context() : context(), result(), value(), fromarg()
2627 {
2628 }
2629 public cmsx.intermediate.Context* context;
2630 public Value* result;
2631 public Instruction* value;
2632 public Value* fromarg;
2633 }
2634 }
2635
2636 public class TruncateInstructionRule : System.Text.Parsing.RuleParser
2637 {
2638 public TruncateInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
2639 {
2640 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
2641 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
2642 SetValueTypeName(ToUtf32("Instruction*"));
2643 }
2644 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2645 {
2646 parsingData->PushContext(Id(), new Context());
2647 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2648 UniquePtr<Object> result_value = stack.Pop();
2649 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
2650 UniquePtr<Object> context_value = stack.Pop();
2651 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
2652 }
2653 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2654 {
2655 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2656 if (matched)
2657 {
2658 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
2659 }
2660 parsingData->PopContext(Id());
2661 }
2662 public override void Link()
2663 {
2664 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
2665 a0ActionParser->SetAction(A0Action);
2666 NonterminalParser* argNonterminalParser = GetNonterminal(ToUtf32("arg"));
2667 argNonterminalParser->SetPre(Prearg);
2668 argNonterminalParser->SetPost(Postarg);
2669 }
2670 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2671 {
2672 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2673 context->value = new TruncateInstruction(context->result, context->fromarg, span.lineNumber);
2674 }
2675 public void Prearg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2676 {
2677 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2678 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
2679 }
2680 public void Postarg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2681 {
2682 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2683 if (matched)
2684 {
2685 UniquePtr<Object> fromarg_value = stack.Pop();
2686 context->fromarg = *cast<ValueObject<Value*>*>(fromarg_value.Get());
2687 }
2688 }
2689 public class Context : System.Text.Parsing.Context
2690 {
2691 public Context() : context(), result(), value(), fromarg()
2692 {
2693 }
2694 public cmsx.intermediate.Context* context;
2695 public Value* result;
2696 public Instruction* value;
2697 public Value* fromarg;
2698 }
2699 }
2700
2701 public class BitCastInstructionRule : System.Text.Parsing.RuleParser
2702 {
2703 public BitCastInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
2704 {
2705 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
2706 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
2707 SetValueTypeName(ToUtf32("Instruction*"));
2708 }
2709 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2710 {
2711 parsingData->PushContext(Id(), new Context());
2712 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2713 UniquePtr<Object> result_value = stack.Pop();
2714 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
2715 UniquePtr<Object> context_value = stack.Pop();
2716 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
2717 }
2718 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2719 {
2720 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2721 if (matched)
2722 {
2723 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
2724 }
2725 parsingData->PopContext(Id());
2726 }
2727 public override void Link()
2728 {
2729 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
2730 a0ActionParser->SetAction(A0Action);
2731 NonterminalParser* argNonterminalParser = GetNonterminal(ToUtf32("arg"));
2732 argNonterminalParser->SetPre(Prearg);
2733 argNonterminalParser->SetPost(Postarg);
2734 }
2735 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2736 {
2737 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2738 context->value = new BitCastInstruction(context->result, context->fromarg, span.lineNumber);
2739 }
2740 public void Prearg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2741 {
2742 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2743 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
2744 }
2745 public void Postarg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2746 {
2747 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2748 if (matched)
2749 {
2750 UniquePtr<Object> fromarg_value = stack.Pop();
2751 context->fromarg = *cast<ValueObject<Value*>*>(fromarg_value.Get());
2752 }
2753 }
2754 public class Context : System.Text.Parsing.Context
2755 {
2756 public Context() : context(), result(), value(), fromarg()
2757 {
2758 }
2759 public cmsx.intermediate.Context* context;
2760 public Value* result;
2761 public Instruction* value;
2762 public Value* fromarg;
2763 }
2764 }
2765
2766 public class IntToFloatInstructionRule : System.Text.Parsing.RuleParser
2767 {
2768 public IntToFloatInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
2769 {
2770 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
2771 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
2772 SetValueTypeName(ToUtf32("Instruction*"));
2773 }
2774 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2775 {
2776 parsingData->PushContext(Id(), new Context());
2777 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2778 UniquePtr<Object> result_value = stack.Pop();
2779 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
2780 UniquePtr<Object> context_value = stack.Pop();
2781 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
2782 }
2783 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2784 {
2785 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2786 if (matched)
2787 {
2788 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
2789 }
2790 parsingData->PopContext(Id());
2791 }
2792 public override void Link()
2793 {
2794 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
2795 a0ActionParser->SetAction(A0Action);
2796 NonterminalParser* argNonterminalParser = GetNonterminal(ToUtf32("arg"));
2797 argNonterminalParser->SetPre(Prearg);
2798 argNonterminalParser->SetPost(Postarg);
2799 }
2800 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2801 {
2802 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2803 context->value = new IntToFloatInstruction(context->result, context->fromarg, span.lineNumber);
2804 }
2805 public void Prearg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2806 {
2807 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2808 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
2809 }
2810 public void Postarg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2811 {
2812 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2813 if (matched)
2814 {
2815 UniquePtr<Object> fromarg_value = stack.Pop();
2816 context->fromarg = *cast<ValueObject<Value*>*>(fromarg_value.Get());
2817 }
2818 }
2819 public class Context : System.Text.Parsing.Context
2820 {
2821 public Context() : context(), result(), value(), fromarg()
2822 {
2823 }
2824 public cmsx.intermediate.Context* context;
2825 public Value* result;
2826 public Instruction* value;
2827 public Value* fromarg;
2828 }
2829 }
2830
2831 public class FloatToIntInstructionRule : System.Text.Parsing.RuleParser
2832 {
2833 public FloatToIntInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
2834 {
2835 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
2836 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
2837 SetValueTypeName(ToUtf32("Instruction*"));
2838 }
2839 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2840 {
2841 parsingData->PushContext(Id(), new Context());
2842 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2843 UniquePtr<Object> result_value = stack.Pop();
2844 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
2845 UniquePtr<Object> context_value = stack.Pop();
2846 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
2847 }
2848 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2849 {
2850 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2851 if (matched)
2852 {
2853 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
2854 }
2855 parsingData->PopContext(Id());
2856 }
2857 public override void Link()
2858 {
2859 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
2860 a0ActionParser->SetAction(A0Action);
2861 NonterminalParser* argNonterminalParser = GetNonterminal(ToUtf32("arg"));
2862 argNonterminalParser->SetPre(Prearg);
2863 argNonterminalParser->SetPost(Postarg);
2864 }
2865 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2866 {
2867 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2868 context->value = new FloatToIntInstruction(context->result, context->fromarg, span.lineNumber);
2869 }
2870 public void Prearg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2871 {
2872 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2873 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
2874 }
2875 public void Postarg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2876 {
2877 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2878 if (matched)
2879 {
2880 UniquePtr<Object> fromarg_value = stack.Pop();
2881 context->fromarg = *cast<ValueObject<Value*>*>(fromarg_value.Get());
2882 }
2883 }
2884 public class Context : System.Text.Parsing.Context
2885 {
2886 public Context() : context(), result(), value(), fromarg()
2887 {
2888 }
2889 public cmsx.intermediate.Context* context;
2890 public Value* result;
2891 public Instruction* value;
2892 public Value* fromarg;
2893 }
2894 }
2895
2896 public class IntToPtrInstructionRule : System.Text.Parsing.RuleParser
2897 {
2898 public IntToPtrInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
2899 {
2900 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
2901 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
2902 SetValueTypeName(ToUtf32("Instruction*"));
2903 }
2904 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2905 {
2906 parsingData->PushContext(Id(), new Context());
2907 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2908 UniquePtr<Object> result_value = stack.Pop();
2909 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
2910 UniquePtr<Object> context_value = stack.Pop();
2911 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
2912 }
2913 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2914 {
2915 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2916 if (matched)
2917 {
2918 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
2919 }
2920 parsingData->PopContext(Id());
2921 }
2922 public override void Link()
2923 {
2924 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
2925 a0ActionParser->SetAction(A0Action);
2926 NonterminalParser* argNonterminalParser = GetNonterminal(ToUtf32("arg"));
2927 argNonterminalParser->SetPre(Prearg);
2928 argNonterminalParser->SetPost(Postarg);
2929 }
2930 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2931 {
2932 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2933 context->value = new IntToPtrInstruction(context->result, context->fromarg, span.lineNumber);
2934 }
2935 public void Prearg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2936 {
2937 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2938 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
2939 }
2940 public void Postarg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2941 {
2942 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2943 if (matched)
2944 {
2945 UniquePtr<Object> fromarg_value = stack.Pop();
2946 context->fromarg = *cast<ValueObject<Value*>*>(fromarg_value.Get());
2947 }
2948 }
2949 public class Context : System.Text.Parsing.Context
2950 {
2951 public Context() : context(), result(), value(), fromarg()
2952 {
2953 }
2954 public cmsx.intermediate.Context* context;
2955 public Value* result;
2956 public Instruction* value;
2957 public Value* fromarg;
2958 }
2959 }
2960
2961 public class PtrToIntInstructionRule : System.Text.Parsing.RuleParser
2962 {
2963 public PtrToIntInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
2964 {
2965 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
2966 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
2967 SetValueTypeName(ToUtf32("Instruction*"));
2968 }
2969 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2970 {
2971 parsingData->PushContext(Id(), new Context());
2972 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2973 UniquePtr<Object> result_value = stack.Pop();
2974 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
2975 UniquePtr<Object> context_value = stack.Pop();
2976 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
2977 }
2978 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2979 {
2980 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2981 if (matched)
2982 {
2983 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
2984 }
2985 parsingData->PopContext(Id());
2986 }
2987 public override void Link()
2988 {
2989 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
2990 a0ActionParser->SetAction(A0Action);
2991 NonterminalParser* argNonterminalParser = GetNonterminal(ToUtf32("arg"));
2992 argNonterminalParser->SetPre(Prearg);
2993 argNonterminalParser->SetPost(Postarg);
2994 }
2995 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2996 {
2997 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2998 context->value = new PtrToIntInstruction(context->result, context->fromarg, span.lineNumber);
2999 }
3000 public void Prearg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3001 {
3002 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3003 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
3004 }
3005 public void Postarg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3006 {
3007 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3008 if (matched)
3009 {
3010 UniquePtr<Object> fromarg_value = stack.Pop();
3011 context->fromarg = *cast<ValueObject<Value*>*>(fromarg_value.Get());
3012 }
3013 }
3014 public class Context : System.Text.Parsing.Context
3015 {
3016 public Context() : context(), result(), value(), fromarg()
3017 {
3018 }
3019 public cmsx.intermediate.Context* context;
3020 public Value* result;
3021 public Instruction* value;
3022 public Value* fromarg;
3023 }
3024 }
3025
3026 public class BinaryInstructionRule : System.Text.Parsing.RuleParser
3027 {
3028 public BinaryInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
3029 {
3030 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
3031 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
3032 SetValueTypeName(ToUtf32("Instruction*"));
3033 }
3034 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3035 {
3036 parsingData->PushContext(Id(), new Context());
3037 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3038 UniquePtr<Object> result_value = stack.Pop();
3039 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
3040 UniquePtr<Object> context_value = stack.Pop();
3041 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
3042 }
3043 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3044 {
3045 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3046 if (matched)
3047 {
3048 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
3049 }
3050 parsingData->PopContext(Id());
3051 }
3052 public override void Link()
3053 {
3054 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
3055 a0ActionParser->SetAction(A0Action);
3056 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
3057 a1ActionParser->SetAction(A1Action);
3058 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
3059 a2ActionParser->SetAction(A2Action);
3060 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
3061 a3ActionParser->SetAction(A3Action);
3062 ActionParser* a4ActionParser = GetAction(ToUtf32("A4"));
3063 a4ActionParser->SetAction(A4Action);
3064 ActionParser* a5ActionParser = GetAction(ToUtf32("A5"));
3065 a5ActionParser->SetAction(A5Action);
3066 ActionParser* a6ActionParser = GetAction(ToUtf32("A6"));
3067 a6ActionParser->SetAction(A6Action);
3068 ActionParser* a7ActionParser = GetAction(ToUtf32("A7"));
3069 a7ActionParser->SetAction(A7Action);
3070 ActionParser* a8ActionParser = GetAction(ToUtf32("A8"));
3071 a8ActionParser->SetAction(A8Action);
3072 ActionParser* a9ActionParser = GetAction(ToUtf32("A9"));
3073 a9ActionParser->SetAction(A9Action);
3074 ActionParser* a10ActionParser = GetAction(ToUtf32("A10"));
3075 a10ActionParser->SetAction(A10Action);
3076 ActionParser* a11ActionParser = GetAction(ToUtf32("A11"));
3077 a11ActionParser->SetAction(A11Action);
3078 NonterminalParser* addInstructionNonterminalParser = GetNonterminal(ToUtf32("AddInstruction"));
3079 addInstructionNonterminalParser->SetPre(PreAddInstruction);
3080 addInstructionNonterminalParser->SetPost(PostAddInstruction);
3081 NonterminalParser* subInstructionNonterminalParser = GetNonterminal(ToUtf32("SubInstruction"));
3082 subInstructionNonterminalParser->SetPre(PreSubInstruction);
3083 subInstructionNonterminalParser->SetPost(PostSubInstruction);
3084 NonterminalParser* mulInstructionNonterminalParser = GetNonterminal(ToUtf32("MulInstruction"));
3085 mulInstructionNonterminalParser->SetPre(PreMulInstruction);
3086 mulInstructionNonterminalParser->SetPost(PostMulInstruction);
3087 NonterminalParser* divInstructionNonterminalParser = GetNonterminal(ToUtf32("DivInstruction"));
3088 divInstructionNonterminalParser->SetPre(PreDivInstruction);
3089 divInstructionNonterminalParser->SetPost(PostDivInstruction);
3090 NonterminalParser* modInstructionNonterminalParser = GetNonterminal(ToUtf32("ModInstruction"));
3091 modInstructionNonterminalParser->SetPre(PreModInstruction);
3092 modInstructionNonterminalParser->SetPost(PostModInstruction);
3093 NonterminalParser* andInstructionNonterminalParser = GetNonterminal(ToUtf32("AndInstruction"));
3094 andInstructionNonterminalParser->SetPre(PreAndInstruction);
3095 andInstructionNonterminalParser->SetPost(PostAndInstruction);
3096 NonterminalParser* orInstructionNonterminalParser = GetNonterminal(ToUtf32("OrInstruction"));
3097 orInstructionNonterminalParser->SetPre(PreOrInstruction);
3098 orInstructionNonterminalParser->SetPost(PostOrInstruction);
3099 NonterminalParser* xorInstructionNonterminalParser = GetNonterminal(ToUtf32("XorInstruction"));
3100 xorInstructionNonterminalParser->SetPre(PreXorInstruction);
3101 xorInstructionNonterminalParser->SetPost(PostXorInstruction);
3102 NonterminalParser* shlInstructionNonterminalParser = GetNonterminal(ToUtf32("ShlInstruction"));
3103 shlInstructionNonterminalParser->SetPre(PreShlInstruction);
3104 shlInstructionNonterminalParser->SetPost(PostShlInstruction);
3105 NonterminalParser* shrInstructionNonterminalParser = GetNonterminal(ToUtf32("ShrInstruction"));
3106 shrInstructionNonterminalParser->SetPre(PreShrInstruction);
3107 shrInstructionNonterminalParser->SetPost(PostShrInstruction);
3108 NonterminalParser* equalInstructionNonterminalParser = GetNonterminal(ToUtf32("EqualInstruction"));
3109 equalInstructionNonterminalParser->SetPre(PreEqualInstruction);
3110 equalInstructionNonterminalParser->SetPost(PostEqualInstruction);
3111 NonterminalParser* lessInstructionNonterminalParser = GetNonterminal(ToUtf32("LessInstruction"));
3112 lessInstructionNonterminalParser->SetPre(PreLessInstruction);
3113 lessInstructionNonterminalParser->SetPost(PostLessInstruction);
3114 }
3115 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3116 {
3117 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3118 context->value = context->fromAddInstruction;
3119 }
3120 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3121 {
3122 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3123 context->value = context->fromSubInstruction;
3124 }
3125 public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3126 {
3127 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3128 context->value = context->fromMulInstruction;
3129 }
3130 public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3131 {
3132 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3133 context->value = context->fromDivInstruction;
3134 }
3135 public void A4Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3136 {
3137 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3138 context->value = context->fromModInstruction;
3139 }
3140 public void A5Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3141 {
3142 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3143 context->value = context->fromAndInstruction;
3144 }
3145 public void A6Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3146 {
3147 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3148 context->value = context->fromOrInstruction;
3149 }
3150 public void A7Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3151 {
3152 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3153 context->value = context->fromXorInstruction;
3154 }
3155 public void A8Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3156 {
3157 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3158 context->value = context->fromShlInstruction;
3159 }
3160 public void A9Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3161 {
3162 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3163 context->value = context->fromShrInstruction;
3164 }
3165 public void A10Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3166 {
3167 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3168 context->value = context->fromEqualInstruction;
3169 }
3170 public void A11Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3171 {
3172 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3173 context->value = context->fromLessInstruction;
3174 }
3175 public void PreAddInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3176 {
3177 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3178 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
3179 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
3180 }
3181 public void PostAddInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3182 {
3183 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3184 if (matched)
3185 {
3186 UniquePtr<Object> fromAddInstruction_value = stack.Pop();
3187 context->fromAddInstruction = *cast<ValueObject<Instruction*>*>(fromAddInstruction_value.Get());
3188 }
3189 }
3190 public void PreSubInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3191 {
3192 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3193 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
3194 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
3195 }
3196 public void PostSubInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3197 {
3198 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3199 if (matched)
3200 {
3201 UniquePtr<Object> fromSubInstruction_value = stack.Pop();
3202 context->fromSubInstruction = *cast<ValueObject<Instruction*>*>(fromSubInstruction_value.Get());
3203 }
3204 }
3205 public void PreMulInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3206 {
3207 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3208 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
3209 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
3210 }
3211 public void PostMulInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3212 {
3213 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3214 if (matched)
3215 {
3216 UniquePtr<Object> fromMulInstruction_value = stack.Pop();
3217 context->fromMulInstruction = *cast<ValueObject<Instruction*>*>(fromMulInstruction_value.Get());
3218 }
3219 }
3220 public void PreDivInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3221 {
3222 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3223 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
3224 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
3225 }
3226 public void PostDivInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3227 {
3228 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3229 if (matched)
3230 {
3231 UniquePtr<Object> fromDivInstruction_value = stack.Pop();
3232 context->fromDivInstruction = *cast<ValueObject<Instruction*>*>(fromDivInstruction_value.Get());
3233 }
3234 }
3235 public void PreModInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3236 {
3237 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3238 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
3239 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
3240 }
3241 public void PostModInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3242 {
3243 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3244 if (matched)
3245 {
3246 UniquePtr<Object> fromModInstruction_value = stack.Pop();
3247 context->fromModInstruction = *cast<ValueObject<Instruction*>*>(fromModInstruction_value.Get());
3248 }
3249 }
3250 public void PreAndInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3251 {
3252 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3253 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
3254 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
3255 }
3256 public void PostAndInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3257 {
3258 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3259 if (matched)
3260 {
3261 UniquePtr<Object> fromAndInstruction_value = stack.Pop();
3262 context->fromAndInstruction = *cast<ValueObject<Instruction*>*>(fromAndInstruction_value.Get());
3263 }
3264 }
3265 public void PreOrInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3266 {
3267 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3268 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
3269 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
3270 }
3271 public void PostOrInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3272 {
3273 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3274 if (matched)
3275 {
3276 UniquePtr<Object> fromOrInstruction_value = stack.Pop();
3277 context->fromOrInstruction = *cast<ValueObject<Instruction*>*>(fromOrInstruction_value.Get());
3278 }
3279 }
3280 public void PreXorInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3281 {
3282 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3283 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
3284 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
3285 }
3286 public void PostXorInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3287 {
3288 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3289 if (matched)
3290 {
3291 UniquePtr<Object> fromXorInstruction_value = stack.Pop();
3292 context->fromXorInstruction = *cast<ValueObject<Instruction*>*>(fromXorInstruction_value.Get());
3293 }
3294 }
3295 public void PreShlInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3296 {
3297 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3298 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
3299 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
3300 }
3301 public void PostShlInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3302 {
3303 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3304 if (matched)
3305 {
3306 UniquePtr<Object> fromShlInstruction_value = stack.Pop();
3307 context->fromShlInstruction = *cast<ValueObject<Instruction*>*>(fromShlInstruction_value.Get());
3308 }
3309 }
3310 public void PreShrInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3311 {
3312 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3313 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
3314 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
3315 }
3316 public void PostShrInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3317 {
3318 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3319 if (matched)
3320 {
3321 UniquePtr<Object> fromShrInstruction_value = stack.Pop();
3322 context->fromShrInstruction = *cast<ValueObject<Instruction*>*>(fromShrInstruction_value.Get());
3323 }
3324 }
3325 public void PreEqualInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3326 {
3327 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3328 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
3329 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
3330 }
3331 public void PostEqualInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3332 {
3333 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3334 if (matched)
3335 {
3336 UniquePtr<Object> fromEqualInstruction_value = stack.Pop();
3337 context->fromEqualInstruction = *cast<ValueObject<Instruction*>*>(fromEqualInstruction_value.Get());
3338 }
3339 }
3340 public void PreLessInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3341 {
3342 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3343 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
3344 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
3345 }
3346 public void PostLessInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3347 {
3348 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3349 if (matched)
3350 {
3351 UniquePtr<Object> fromLessInstruction_value = stack.Pop();
3352 context->fromLessInstruction = *cast<ValueObject<Instruction*>*>(fromLessInstruction_value.Get());
3353 }
3354 }
3355 public class Context : System.Text.Parsing.Context
3356 {
3357 public Context() : context(), result(), value(), fromAddInstruction(), fromSubInstruction(), fromMulInstruction(), fromDivInstruction(), fromModInstruction(), fromAndInstruction(), fromOrInstruction(), fromXorInstruction(), fromShlInstruction(), fromShrInstruction(), fromEqualInstruction(), fromLessInstruction()
3358 {
3359 }
3360 public cmsx.intermediate.Context* context;
3361 public Value* result;
3362 public Instruction* value;
3363 public Instruction* fromAddInstruction;
3364 public Instruction* fromSubInstruction;
3365 public Instruction* fromMulInstruction;
3366 public Instruction* fromDivInstruction;
3367 public Instruction* fromModInstruction;
3368 public Instruction* fromAndInstruction;
3369 public Instruction* fromOrInstruction;
3370 public Instruction* fromXorInstruction;
3371 public Instruction* fromShlInstruction;
3372 public Instruction* fromShrInstruction;
3373 public Instruction* fromEqualInstruction;
3374 public Instruction* fromLessInstruction;
3375 }
3376 }
3377
3378 public class AddInstructionRule : System.Text.Parsing.RuleParser
3379 {
3380 public AddInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
3381 {
3382 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
3383 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
3384 SetValueTypeName(ToUtf32("Instruction*"));
3385 }
3386 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3387 {
3388 parsingData->PushContext(Id(), new Context());
3389 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3390 UniquePtr<Object> result_value = stack.Pop();
3391 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
3392 UniquePtr<Object> context_value = stack.Pop();
3393 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
3394 }
3395 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3396 {
3397 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3398 if (matched)
3399 {
3400 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
3401 }
3402 parsingData->PopContext(Id());
3403 }
3404 public override void Link()
3405 {
3406 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
3407 a0ActionParser->SetAction(A0Action);
3408 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
3409 leftNonterminalParser->SetPre(Preleft);
3410 leftNonterminalParser->SetPost(Postleft);
3411 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
3412 rightNonterminalParser->SetPre(Preright);
3413 rightNonterminalParser->SetPost(Postright);
3414 }
3415 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3416 {
3417 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3418 context->value = new AddInstruction(context->result, context->fromleft, context->fromright, span.lineNumber);
3419 }
3420 public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3421 {
3422 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3423 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
3424 }
3425 public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3426 {
3427 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3428 if (matched)
3429 {
3430 UniquePtr<Object> fromleft_value = stack.Pop();
3431 context->fromleft = *cast<ValueObject<Value*>*>(fromleft_value.Get());
3432 }
3433 }
3434 public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3435 {
3436 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3437 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
3438 }
3439 public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3440 {
3441 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3442 if (matched)
3443 {
3444 UniquePtr<Object> fromright_value = stack.Pop();
3445 context->fromright = *cast<ValueObject<Value*>*>(fromright_value.Get());
3446 }
3447 }
3448 public class Context : System.Text.Parsing.Context
3449 {
3450 public Context() : context(), result(), value(), fromleft(), fromright()
3451 {
3452 }
3453 public cmsx.intermediate.Context* context;
3454 public Value* result;
3455 public Instruction* value;
3456 public Value* fromleft;
3457 public Value* fromright;
3458 }
3459 }
3460
3461 public class SubInstructionRule : System.Text.Parsing.RuleParser
3462 {
3463 public SubInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
3464 {
3465 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
3466 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
3467 SetValueTypeName(ToUtf32("Instruction*"));
3468 }
3469 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3470 {
3471 parsingData->PushContext(Id(), new Context());
3472 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3473 UniquePtr<Object> result_value = stack.Pop();
3474 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
3475 UniquePtr<Object> context_value = stack.Pop();
3476 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
3477 }
3478 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3479 {
3480 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3481 if (matched)
3482 {
3483 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
3484 }
3485 parsingData->PopContext(Id());
3486 }
3487 public override void Link()
3488 {
3489 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
3490 a0ActionParser->SetAction(A0Action);
3491 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
3492 leftNonterminalParser->SetPre(Preleft);
3493 leftNonterminalParser->SetPost(Postleft);
3494 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
3495 rightNonterminalParser->SetPre(Preright);
3496 rightNonterminalParser->SetPost(Postright);
3497 }
3498 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3499 {
3500 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3501 context->value = new SubInstruction(context->result, context->fromleft, context->fromright, span.lineNumber);
3502 }
3503 public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3504 {
3505 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3506 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
3507 }
3508 public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3509 {
3510 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3511 if (matched)
3512 {
3513 UniquePtr<Object> fromleft_value = stack.Pop();
3514 context->fromleft = *cast<ValueObject<Value*>*>(fromleft_value.Get());
3515 }
3516 }
3517 public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3518 {
3519 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3520 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
3521 }
3522 public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3523 {
3524 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3525 if (matched)
3526 {
3527 UniquePtr<Object> fromright_value = stack.Pop();
3528 context->fromright = *cast<ValueObject<Value*>*>(fromright_value.Get());
3529 }
3530 }
3531 public class Context : System.Text.Parsing.Context
3532 {
3533 public Context() : context(), result(), value(), fromleft(), fromright()
3534 {
3535 }
3536 public cmsx.intermediate.Context* context;
3537 public Value* result;
3538 public Instruction* value;
3539 public Value* fromleft;
3540 public Value* fromright;
3541 }
3542 }
3543
3544 public class MulInstructionRule : System.Text.Parsing.RuleParser
3545 {
3546 public MulInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
3547 {
3548 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
3549 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
3550 SetValueTypeName(ToUtf32("Instruction*"));
3551 }
3552 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3553 {
3554 parsingData->PushContext(Id(), new Context());
3555 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3556 UniquePtr<Object> result_value = stack.Pop();
3557 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
3558 UniquePtr<Object> context_value = stack.Pop();
3559 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
3560 }
3561 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3562 {
3563 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3564 if (matched)
3565 {
3566 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
3567 }
3568 parsingData->PopContext(Id());
3569 }
3570 public override void Link()
3571 {
3572 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
3573 a0ActionParser->SetAction(A0Action);
3574 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
3575 leftNonterminalParser->SetPre(Preleft);
3576 leftNonterminalParser->SetPost(Postleft);
3577 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
3578 rightNonterminalParser->SetPre(Preright);
3579 rightNonterminalParser->SetPost(Postright);
3580 }
3581 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3582 {
3583 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3584 context->value = new MulInstruction(context->result, context->fromleft, context->fromright, span.lineNumber);
3585 }
3586 public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3587 {
3588 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3589 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
3590 }
3591 public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3592 {
3593 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3594 if (matched)
3595 {
3596 UniquePtr<Object> fromleft_value = stack.Pop();
3597 context->fromleft = *cast<ValueObject<Value*>*>(fromleft_value.Get());
3598 }
3599 }
3600 public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3601 {
3602 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3603 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
3604 }
3605 public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3606 {
3607 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3608 if (matched)
3609 {
3610 UniquePtr<Object> fromright_value = stack.Pop();
3611 context->fromright = *cast<ValueObject<Value*>*>(fromright_value.Get());
3612 }
3613 }
3614 public class Context : System.Text.Parsing.Context
3615 {
3616 public Context() : context(), result(), value(), fromleft(), fromright()
3617 {
3618 }
3619 public cmsx.intermediate.Context* context;
3620 public Value* result;
3621 public Instruction* value;
3622 public Value* fromleft;
3623 public Value* fromright;
3624 }
3625 }
3626
3627 public class DivInstructionRule : System.Text.Parsing.RuleParser
3628 {
3629 public DivInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
3630 {
3631 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
3632 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
3633 SetValueTypeName(ToUtf32("Instruction*"));
3634 }
3635 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3636 {
3637 parsingData->PushContext(Id(), new Context());
3638 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3639 UniquePtr<Object> result_value = stack.Pop();
3640 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
3641 UniquePtr<Object> context_value = stack.Pop();
3642 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
3643 }
3644 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3645 {
3646 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3647 if (matched)
3648 {
3649 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
3650 }
3651 parsingData->PopContext(Id());
3652 }
3653 public override void Link()
3654 {
3655 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
3656 a0ActionParser->SetAction(A0Action);
3657 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
3658 leftNonterminalParser->SetPre(Preleft);
3659 leftNonterminalParser->SetPost(Postleft);
3660 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
3661 rightNonterminalParser->SetPre(Preright);
3662 rightNonterminalParser->SetPost(Postright);
3663 }
3664 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3665 {
3666 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3667 context->value = new DivInstruction(context->result, context->fromleft, context->fromright, span.lineNumber);
3668 }
3669 public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3670 {
3671 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3672 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
3673 }
3674 public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3675 {
3676 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3677 if (matched)
3678 {
3679 UniquePtr<Object> fromleft_value = stack.Pop();
3680 context->fromleft = *cast<ValueObject<Value*>*>(fromleft_value.Get());
3681 }
3682 }
3683 public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3684 {
3685 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3686 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
3687 }
3688 public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3689 {
3690 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3691 if (matched)
3692 {
3693 UniquePtr<Object> fromright_value = stack.Pop();
3694 context->fromright = *cast<ValueObject<Value*>*>(fromright_value.Get());
3695 }
3696 }
3697 public class Context : System.Text.Parsing.Context
3698 {
3699 public Context() : context(), result(), value(), fromleft(), fromright()
3700 {
3701 }
3702 public cmsx.intermediate.Context* context;
3703 public Value* result;
3704 public Instruction* value;
3705 public Value* fromleft;
3706 public Value* fromright;
3707 }
3708 }
3709
3710 public class ModInstructionRule : System.Text.Parsing.RuleParser
3711 {
3712 public ModInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
3713 {
3714 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
3715 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
3716 SetValueTypeName(ToUtf32("Instruction*"));
3717 }
3718 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3719 {
3720 parsingData->PushContext(Id(), new Context());
3721 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3722 UniquePtr<Object> result_value = stack.Pop();
3723 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
3724 UniquePtr<Object> context_value = stack.Pop();
3725 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
3726 }
3727 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3728 {
3729 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3730 if (matched)
3731 {
3732 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
3733 }
3734 parsingData->PopContext(Id());
3735 }
3736 public override void Link()
3737 {
3738 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
3739 a0ActionParser->SetAction(A0Action);
3740 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
3741 leftNonterminalParser->SetPre(Preleft);
3742 leftNonterminalParser->SetPost(Postleft);
3743 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
3744 rightNonterminalParser->SetPre(Preright);
3745 rightNonterminalParser->SetPost(Postright);
3746 }
3747 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3748 {
3749 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3750 context->value = new ModInstruction(context->result, context->fromleft, context->fromright, span.lineNumber);
3751 }
3752 public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3753 {
3754 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3755 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
3756 }
3757 public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3758 {
3759 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3760 if (matched)
3761 {
3762 UniquePtr<Object> fromleft_value = stack.Pop();
3763 context->fromleft = *cast<ValueObject<Value*>*>(fromleft_value.Get());
3764 }
3765 }
3766 public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3767 {
3768 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3769 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
3770 }
3771 public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3772 {
3773 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3774 if (matched)
3775 {
3776 UniquePtr<Object> fromright_value = stack.Pop();
3777 context->fromright = *cast<ValueObject<Value*>*>(fromright_value.Get());
3778 }
3779 }
3780 public class Context : System.Text.Parsing.Context
3781 {
3782 public Context() : context(), result(), value(), fromleft(), fromright()
3783 {
3784 }
3785 public cmsx.intermediate.Context* context;
3786 public Value* result;
3787 public Instruction* value;
3788 public Value* fromleft;
3789 public Value* fromright;
3790 }
3791 }
3792
3793 public class AndInstructionRule : System.Text.Parsing.RuleParser
3794 {
3795 public AndInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
3796 {
3797 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
3798 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
3799 SetValueTypeName(ToUtf32("Instruction*"));
3800 }
3801 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3802 {
3803 parsingData->PushContext(Id(), new Context());
3804 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3805 UniquePtr<Object> result_value = stack.Pop();
3806 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
3807 UniquePtr<Object> context_value = stack.Pop();
3808 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
3809 }
3810 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3811 {
3812 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3813 if (matched)
3814 {
3815 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
3816 }
3817 parsingData->PopContext(Id());
3818 }
3819 public override void Link()
3820 {
3821 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
3822 a0ActionParser->SetAction(A0Action);
3823 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
3824 leftNonterminalParser->SetPre(Preleft);
3825 leftNonterminalParser->SetPost(Postleft);
3826 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
3827 rightNonterminalParser->SetPre(Preright);
3828 rightNonterminalParser->SetPost(Postright);
3829 }
3830 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3831 {
3832 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3833 context->value = new AndInstruction(context->result, context->fromleft, context->fromright, span.lineNumber);
3834 }
3835 public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3836 {
3837 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3838 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
3839 }
3840 public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3841 {
3842 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3843 if (matched)
3844 {
3845 UniquePtr<Object> fromleft_value = stack.Pop();
3846 context->fromleft = *cast<ValueObject<Value*>*>(fromleft_value.Get());
3847 }
3848 }
3849 public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3850 {
3851 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3852 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
3853 }
3854 public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3855 {
3856 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3857 if (matched)
3858 {
3859 UniquePtr<Object> fromright_value = stack.Pop();
3860 context->fromright = *cast<ValueObject<Value*>*>(fromright_value.Get());
3861 }
3862 }
3863 public class Context : System.Text.Parsing.Context
3864 {
3865 public Context() : context(), result(), value(), fromleft(), fromright()
3866 {
3867 }
3868 public cmsx.intermediate.Context* context;
3869 public Value* result;
3870 public Instruction* value;
3871 public Value* fromleft;
3872 public Value* fromright;
3873 }
3874 }
3875
3876 public class OrInstructionRule : System.Text.Parsing.RuleParser
3877 {
3878 public OrInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
3879 {
3880 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
3881 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
3882 SetValueTypeName(ToUtf32("Instruction*"));
3883 }
3884 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3885 {
3886 parsingData->PushContext(Id(), new Context());
3887 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3888 UniquePtr<Object> result_value = stack.Pop();
3889 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
3890 UniquePtr<Object> context_value = stack.Pop();
3891 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
3892 }
3893 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3894 {
3895 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3896 if (matched)
3897 {
3898 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
3899 }
3900 parsingData->PopContext(Id());
3901 }
3902 public override void Link()
3903 {
3904 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
3905 a0ActionParser->SetAction(A0Action);
3906 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
3907 leftNonterminalParser->SetPre(Preleft);
3908 leftNonterminalParser->SetPost(Postleft);
3909 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
3910 rightNonterminalParser->SetPre(Preright);
3911 rightNonterminalParser->SetPost(Postright);
3912 }
3913 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3914 {
3915 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3916 context->value = new OrInstruction(context->result, context->fromleft, context->fromright, span.lineNumber);
3917 }
3918 public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3919 {
3920 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3921 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
3922 }
3923 public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3924 {
3925 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3926 if (matched)
3927 {
3928 UniquePtr<Object> fromleft_value = stack.Pop();
3929 context->fromleft = *cast<ValueObject<Value*>*>(fromleft_value.Get());
3930 }
3931 }
3932 public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3933 {
3934 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3935 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
3936 }
3937 public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3938 {
3939 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3940 if (matched)
3941 {
3942 UniquePtr<Object> fromright_value = stack.Pop();
3943 context->fromright = *cast<ValueObject<Value*>*>(fromright_value.Get());
3944 }
3945 }
3946 public class Context : System.Text.Parsing.Context
3947 {
3948 public Context() : context(), result(), value(), fromleft(), fromright()
3949 {
3950 }
3951 public cmsx.intermediate.Context* context;
3952 public Value* result;
3953 public Instruction* value;
3954 public Value* fromleft;
3955 public Value* fromright;
3956 }
3957 }
3958
3959 public class XorInstructionRule : System.Text.Parsing.RuleParser
3960 {
3961 public XorInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
3962 {
3963 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
3964 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
3965 SetValueTypeName(ToUtf32("Instruction*"));
3966 }
3967 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3968 {
3969 parsingData->PushContext(Id(), new Context());
3970 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3971 UniquePtr<Object> result_value = stack.Pop();
3972 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
3973 UniquePtr<Object> context_value = stack.Pop();
3974 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
3975 }
3976 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3977 {
3978 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3979 if (matched)
3980 {
3981 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
3982 }
3983 parsingData->PopContext(Id());
3984 }
3985 public override void Link()
3986 {
3987 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
3988 a0ActionParser->SetAction(A0Action);
3989 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
3990 leftNonterminalParser->SetPre(Preleft);
3991 leftNonterminalParser->SetPost(Postleft);
3992 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
3993 rightNonterminalParser->SetPre(Preright);
3994 rightNonterminalParser->SetPost(Postright);
3995 }
3996 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3997 {
3998 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3999 context->value = new XorInstruction(context->result, context->fromleft, context->fromright, span.lineNumber);
4000 }
4001 public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4002 {
4003 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4004 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
4005 }
4006 public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4007 {
4008 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4009 if (matched)
4010 {
4011 UniquePtr<Object> fromleft_value = stack.Pop();
4012 context->fromleft = *cast<ValueObject<Value*>*>(fromleft_value.Get());
4013 }
4014 }
4015 public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4016 {
4017 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4018 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
4019 }
4020 public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4021 {
4022 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4023 if (matched)
4024 {
4025 UniquePtr<Object> fromright_value = stack.Pop();
4026 context->fromright = *cast<ValueObject<Value*>*>(fromright_value.Get());
4027 }
4028 }
4029 public class Context : System.Text.Parsing.Context
4030 {
4031 public Context() : context(), result(), value(), fromleft(), fromright()
4032 {
4033 }
4034 public cmsx.intermediate.Context* context;
4035 public Value* result;
4036 public Instruction* value;
4037 public Value* fromleft;
4038 public Value* fromright;
4039 }
4040 }
4041
4042 public class ShlInstructionRule : System.Text.Parsing.RuleParser
4043 {
4044 public ShlInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
4045 {
4046 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
4047 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
4048 SetValueTypeName(ToUtf32("Instruction*"));
4049 }
4050 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4051 {
4052 parsingData->PushContext(Id(), new Context());
4053 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4054 UniquePtr<Object> result_value = stack.Pop();
4055 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
4056 UniquePtr<Object> context_value = stack.Pop();
4057 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
4058 }
4059 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4060 {
4061 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4062 if (matched)
4063 {
4064 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
4065 }
4066 parsingData->PopContext(Id());
4067 }
4068 public override void Link()
4069 {
4070 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
4071 a0ActionParser->SetAction(A0Action);
4072 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
4073 leftNonterminalParser->SetPre(Preleft);
4074 leftNonterminalParser->SetPost(Postleft);
4075 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
4076 rightNonterminalParser->SetPre(Preright);
4077 rightNonterminalParser->SetPost(Postright);
4078 }
4079 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4080 {
4081 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4082 context->value = new ShlInstruction(context->result, context->fromleft, context->fromright, span.lineNumber);
4083 }
4084 public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4085 {
4086 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4087 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
4088 }
4089 public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4090 {
4091 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4092 if (matched)
4093 {
4094 UniquePtr<Object> fromleft_value = stack.Pop();
4095 context->fromleft = *cast<ValueObject<Value*>*>(fromleft_value.Get());
4096 }
4097 }
4098 public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4099 {
4100 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4101 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
4102 }
4103 public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4104 {
4105 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4106 if (matched)
4107 {
4108 UniquePtr<Object> fromright_value = stack.Pop();
4109 context->fromright = *cast<ValueObject<Value*>*>(fromright_value.Get());
4110 }
4111 }
4112 public class Context : System.Text.Parsing.Context
4113 {
4114 public Context() : context(), result(), value(), fromleft(), fromright()
4115 {
4116 }
4117 public cmsx.intermediate.Context* context;
4118 public Value* result;
4119 public Instruction* value;
4120 public Value* fromleft;
4121 public Value* fromright;
4122 }
4123 }
4124
4125 public class ShrInstructionRule : System.Text.Parsing.RuleParser
4126 {
4127 public ShrInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
4128 {
4129 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
4130 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
4131 SetValueTypeName(ToUtf32("Instruction*"));
4132 }
4133 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4134 {
4135 parsingData->PushContext(Id(), new Context());
4136 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4137 UniquePtr<Object> result_value = stack.Pop();
4138 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
4139 UniquePtr<Object> context_value = stack.Pop();
4140 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
4141 }
4142 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4143 {
4144 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4145 if (matched)
4146 {
4147 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
4148 }
4149 parsingData->PopContext(Id());
4150 }
4151 public override void Link()
4152 {
4153 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
4154 a0ActionParser->SetAction(A0Action);
4155 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
4156 leftNonterminalParser->SetPre(Preleft);
4157 leftNonterminalParser->SetPost(Postleft);
4158 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
4159 rightNonterminalParser->SetPre(Preright);
4160 rightNonterminalParser->SetPost(Postright);
4161 }
4162 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4163 {
4164 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4165 context->value = new ShrInstruction(context->result, context->fromleft, context->fromright, span.lineNumber);
4166 }
4167 public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4168 {
4169 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4170 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
4171 }
4172 public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4173 {
4174 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4175 if (matched)
4176 {
4177 UniquePtr<Object> fromleft_value = stack.Pop();
4178 context->fromleft = *cast<ValueObject<Value*>*>(fromleft_value.Get());
4179 }
4180 }
4181 public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4182 {
4183 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4184 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
4185 }
4186 public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4187 {
4188 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4189 if (matched)
4190 {
4191 UniquePtr<Object> fromright_value = stack.Pop();
4192 context->fromright = *cast<ValueObject<Value*>*>(fromright_value.Get());
4193 }
4194 }
4195 public class Context : System.Text.Parsing.Context
4196 {
4197 public Context() : context(), result(), value(), fromleft(), fromright()
4198 {
4199 }
4200 public cmsx.intermediate.Context* context;
4201 public Value* result;
4202 public Instruction* value;
4203 public Value* fromleft;
4204 public Value* fromright;
4205 }
4206 }
4207
4208 public class EqualInstructionRule : System.Text.Parsing.RuleParser
4209 {
4210 public EqualInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
4211 {
4212 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
4213 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
4214 SetValueTypeName(ToUtf32("Instruction*"));
4215 }
4216 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4217 {
4218 parsingData->PushContext(Id(), new Context());
4219 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4220 UniquePtr<Object> result_value = stack.Pop();
4221 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
4222 UniquePtr<Object> context_value = stack.Pop();
4223 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
4224 }
4225 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4226 {
4227 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4228 if (matched)
4229 {
4230 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
4231 }
4232 parsingData->PopContext(Id());
4233 }
4234 public override void Link()
4235 {
4236 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
4237 a0ActionParser->SetAction(A0Action);
4238 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
4239 leftNonterminalParser->SetPre(Preleft);
4240 leftNonterminalParser->SetPost(Postleft);
4241 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
4242 rightNonterminalParser->SetPre(Preright);
4243 rightNonterminalParser->SetPost(Postright);
4244 }
4245 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4246 {
4247 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4248 context->value = new EqualInstruction(context->result, context->fromleft, context->fromright, span.lineNumber);
4249 }
4250 public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4251 {
4252 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4253 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
4254 }
4255 public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4256 {
4257 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4258 if (matched)
4259 {
4260 UniquePtr<Object> fromleft_value = stack.Pop();
4261 context->fromleft = *cast<ValueObject<Value*>*>(fromleft_value.Get());
4262 }
4263 }
4264 public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4265 {
4266 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4267 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
4268 }
4269 public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4270 {
4271 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4272 if (matched)
4273 {
4274 UniquePtr<Object> fromright_value = stack.Pop();
4275 context->fromright = *cast<ValueObject<Value*>*>(fromright_value.Get());
4276 }
4277 }
4278 public class Context : System.Text.Parsing.Context
4279 {
4280 public Context() : context(), result(), value(), fromleft(), fromright()
4281 {
4282 }
4283 public cmsx.intermediate.Context* context;
4284 public Value* result;
4285 public Instruction* value;
4286 public Value* fromleft;
4287 public Value* fromright;
4288 }
4289 }
4290
4291 public class LessInstructionRule : System.Text.Parsing.RuleParser
4292 {
4293 public LessInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
4294 {
4295 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
4296 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
4297 SetValueTypeName(ToUtf32("Instruction*"));
4298 }
4299 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4300 {
4301 parsingData->PushContext(Id(), new Context());
4302 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4303 UniquePtr<Object> result_value = stack.Pop();
4304 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
4305 UniquePtr<Object> context_value = stack.Pop();
4306 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
4307 }
4308 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4309 {
4310 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4311 if (matched)
4312 {
4313 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
4314 }
4315 parsingData->PopContext(Id());
4316 }
4317 public override void Link()
4318 {
4319 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
4320 a0ActionParser->SetAction(A0Action);
4321 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
4322 leftNonterminalParser->SetPre(Preleft);
4323 leftNonterminalParser->SetPost(Postleft);
4324 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
4325 rightNonterminalParser->SetPre(Preright);
4326 rightNonterminalParser->SetPost(Postright);
4327 }
4328 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4329 {
4330 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4331 context->value = new LessInstruction(context->result, context->fromleft, context->fromright, span.lineNumber);
4332 }
4333 public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4334 {
4335 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4336 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
4337 }
4338 public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4339 {
4340 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4341 if (matched)
4342 {
4343 UniquePtr<Object> fromleft_value = stack.Pop();
4344 context->fromleft = *cast<ValueObject<Value*>*>(fromleft_value.Get());
4345 }
4346 }
4347 public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4348 {
4349 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4350 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
4351 }
4352 public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4353 {
4354 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4355 if (matched)
4356 {
4357 UniquePtr<Object> fromright_value = stack.Pop();
4358 context->fromright = *cast<ValueObject<Value*>*>(fromright_value.Get());
4359 }
4360 }
4361 public class Context : System.Text.Parsing.Context
4362 {
4363 public Context() : context(), result(), value(), fromleft(), fromright()
4364 {
4365 }
4366 public cmsx.intermediate.Context* context;
4367 public Value* result;
4368 public Instruction* value;
4369 public Value* fromleft;
4370 public Value* fromright;
4371 }
4372 }
4373
4374 public class ParamInstructionRule : System.Text.Parsing.RuleParser
4375 {
4376 public ParamInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
4377 {
4378 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
4379 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
4380 SetValueTypeName(ToUtf32("Instruction*"));
4381 }
4382 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4383 {
4384 parsingData->PushContext(Id(), new Context());
4385 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4386 UniquePtr<Object> result_value = stack.Pop();
4387 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
4388 UniquePtr<Object> context_value = stack.Pop();
4389 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
4390 }
4391 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4392 {
4393 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4394 if (matched)
4395 {
4396 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
4397 }
4398 parsingData->PopContext(Id());
4399 }
4400 public override void Link()
4401 {
4402 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
4403 a0ActionParser->SetAction(A0Action);
4404 }
4405 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4406 {
4407 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4408 context->value = new ParamInstruction(context->result, span.lineNumber);
4409 }
4410 public class Context : System.Text.Parsing.Context
4411 {
4412 public Context() : context(), result(), value()
4413 {
4414 }
4415 public cmsx.intermediate.Context* context;
4416 public Value* result;
4417 public Instruction* value;
4418 }
4419 }
4420
4421 public class LocalInstructionRule : System.Text.Parsing.RuleParser
4422 {
4423 public LocalInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
4424 {
4425 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
4426 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
4427 SetValueTypeName(ToUtf32("Instruction*"));
4428 }
4429 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4430 {
4431 parsingData->PushContext(Id(), new Context());
4432 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4433 UniquePtr<Object> result_value = stack.Pop();
4434 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
4435 UniquePtr<Object> context_value = stack.Pop();
4436 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
4437 }
4438 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4439 {
4440 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4441 if (matched)
4442 {
4443 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
4444 }
4445 parsingData->PopContext(Id());
4446 }
4447 public override void Link()
4448 {
4449 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
4450 a0ActionParser->SetAction(A0Action);
4451 NonterminalParser* localTypeNonterminalParser = GetNonterminal(ToUtf32("localType"));
4452 localTypeNonterminalParser->SetPre(PrelocalType);
4453 localTypeNonterminalParser->SetPost(PostlocalType);
4454 }
4455 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4456 {
4457 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4458 context->value = new LocalInstruction(context->result, context->fromlocalType, span.lineNumber);
4459 }
4460 public void PrelocalType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4461 {
4462 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4463 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
4464 }
4465 public void PostlocalType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4466 {
4467 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4468 if (matched)
4469 {
4470 UniquePtr<Object> fromlocalType_value = stack.Pop();
4471 context->fromlocalType = *cast<ValueObject<Type*>*>(fromlocalType_value.Get());
4472 }
4473 }
4474 public class Context : System.Text.Parsing.Context
4475 {
4476 public Context() : context(), result(), value(), fromlocalType()
4477 {
4478 }
4479 public cmsx.intermediate.Context* context;
4480 public Value* result;
4481 public Instruction* value;
4482 public Type* fromlocalType;
4483 }
4484 }
4485
4486 public class LoadInstructionRule : System.Text.Parsing.RuleParser
4487 {
4488 public LoadInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
4489 {
4490 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
4491 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
4492 SetValueTypeName(ToUtf32("Instruction*"));
4493 }
4494 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4495 {
4496 parsingData->PushContext(Id(), new Context());
4497 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4498 UniquePtr<Object> result_value = stack.Pop();
4499 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
4500 UniquePtr<Object> context_value = stack.Pop();
4501 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
4502 }
4503 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4504 {
4505 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4506 if (matched)
4507 {
4508 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
4509 }
4510 parsingData->PopContext(Id());
4511 }
4512 public override void Link()
4513 {
4514 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
4515 a0ActionParser->SetAction(A0Action);
4516 NonterminalParser* ptrNonterminalParser = GetNonterminal(ToUtf32("ptr"));
4517 ptrNonterminalParser->SetPre(Preptr);
4518 ptrNonterminalParser->SetPost(Postptr);
4519 }
4520 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4521 {
4522 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4523 context->value = new LoadInstruction(context->result, context->fromptr, span.lineNumber);
4524 }
4525 public void Preptr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4526 {
4527 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4528 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
4529 }
4530 public void Postptr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4531 {
4532 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4533 if (matched)
4534 {
4535 UniquePtr<Object> fromptr_value = stack.Pop();
4536 context->fromptr = *cast<ValueObject<Value*>*>(fromptr_value.Get());
4537 }
4538 }
4539 public class Context : System.Text.Parsing.Context
4540 {
4541 public Context() : context(), result(), value(), fromptr()
4542 {
4543 }
4544 public cmsx.intermediate.Context* context;
4545 public Value* result;
4546 public Instruction* value;
4547 public Value* fromptr;
4548 }
4549 }
4550
4551 public class ElemAddrInstructionRule : System.Text.Parsing.RuleParser
4552 {
4553 public ElemAddrInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
4554 {
4555 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
4556 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
4557 SetValueTypeName(ToUtf32("Instruction*"));
4558 }
4559 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4560 {
4561 parsingData->PushContext(Id(), new Context());
4562 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4563 UniquePtr<Object> result_value = stack.Pop();
4564 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
4565 UniquePtr<Object> context_value = stack.Pop();
4566 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
4567 }
4568 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4569 {
4570 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4571 if (matched)
4572 {
4573 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
4574 }
4575 parsingData->PopContext(Id());
4576 }
4577 public override void Link()
4578 {
4579 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
4580 a0ActionParser->SetAction(A0Action);
4581 NonterminalParser* ptrNonterminalParser = GetNonterminal(ToUtf32("ptr"));
4582 ptrNonterminalParser->SetPre(Preptr);
4583 ptrNonterminalParser->SetPost(Postptr);
4584 NonterminalParser* indexNonterminalParser = GetNonterminal(ToUtf32("index"));
4585 indexNonterminalParser->SetPre(Preindex);
4586 indexNonterminalParser->SetPost(Postindex);
4587 }
4588 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4589 {
4590 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4591 context->value = new ElemAddrInstruction(context->result, context->fromptr, context->fromindex, span.lineNumber);
4592 }
4593 public void Preptr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4594 {
4595 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4596 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
4597 }
4598 public void Postptr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4599 {
4600 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4601 if (matched)
4602 {
4603 UniquePtr<Object> fromptr_value = stack.Pop();
4604 context->fromptr = *cast<ValueObject<Value*>*>(fromptr_value.Get());
4605 }
4606 }
4607 public void Preindex(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4608 {
4609 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4610 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
4611 }
4612 public void Postindex(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4613 {
4614 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4615 if (matched)
4616 {
4617 UniquePtr<Object> fromindex_value = stack.Pop();
4618 context->fromindex = *cast<ValueObject<Value*>*>(fromindex_value.Get());
4619 }
4620 }
4621 public class Context : System.Text.Parsing.Context
4622 {
4623 public Context() : context(), result(), value(), fromptr(), fromindex()
4624 {
4625 }
4626 public cmsx.intermediate.Context* context;
4627 public Value* result;
4628 public Instruction* value;
4629 public Value* fromptr;
4630 public Value* fromindex;
4631 }
4632 }
4633
4634 public class PtrOffsetInstructionRule : System.Text.Parsing.RuleParser
4635 {
4636 public PtrOffsetInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
4637 {
4638 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
4639 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
4640 SetValueTypeName(ToUtf32("Instruction*"));
4641 }
4642 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4643 {
4644 parsingData->PushContext(Id(), new Context());
4645 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4646 UniquePtr<Object> result_value = stack.Pop();
4647 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
4648 UniquePtr<Object> context_value = stack.Pop();
4649 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
4650 }
4651 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4652 {
4653 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4654 if (matched)
4655 {
4656 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
4657 }
4658 parsingData->PopContext(Id());
4659 }
4660 public override void Link()
4661 {
4662 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
4663 a0ActionParser->SetAction(A0Action);
4664 NonterminalParser* ptrNonterminalParser = GetNonterminal(ToUtf32("ptr"));
4665 ptrNonterminalParser->SetPre(Preptr);
4666 ptrNonterminalParser->SetPost(Postptr);
4667 NonterminalParser* offsetNonterminalParser = GetNonterminal(ToUtf32("offset"));
4668 offsetNonterminalParser->SetPre(Preoffset);
4669 offsetNonterminalParser->SetPost(Postoffset);
4670 }
4671 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4672 {
4673 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4674 context->value = new PtrOffsetInstruction(context->result, context->fromptr, context->fromoffset, span.lineNumber);
4675 }
4676 public void Preptr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4677 {
4678 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4679 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
4680 }
4681 public void Postptr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4682 {
4683 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4684 if (matched)
4685 {
4686 UniquePtr<Object> fromptr_value = stack.Pop();
4687 context->fromptr = *cast<ValueObject<Value*>*>(fromptr_value.Get());
4688 }
4689 }
4690 public void Preoffset(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4691 {
4692 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4693 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
4694 }
4695 public void Postoffset(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4696 {
4697 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4698 if (matched)
4699 {
4700 UniquePtr<Object> fromoffset_value = stack.Pop();
4701 context->fromoffset = *cast<ValueObject<Value*>*>(fromoffset_value.Get());
4702 }
4703 }
4704 public class Context : System.Text.Parsing.Context
4705 {
4706 public Context() : context(), result(), value(), fromptr(), fromoffset()
4707 {
4708 }
4709 public cmsx.intermediate.Context* context;
4710 public Value* result;
4711 public Instruction* value;
4712 public Value* fromptr;
4713 public Value* fromoffset;
4714 }
4715 }
4716
4717 public class PtrDiffInstructionRule : System.Text.Parsing.RuleParser
4718 {
4719 public PtrDiffInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
4720 {
4721 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
4722 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
4723 SetValueTypeName(ToUtf32("Instruction*"));
4724 }
4725 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4726 {
4727 parsingData->PushContext(Id(), new Context());
4728 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4729 UniquePtr<Object> result_value = stack.Pop();
4730 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
4731 UniquePtr<Object> context_value = stack.Pop();
4732 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
4733 }
4734 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4735 {
4736 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4737 if (matched)
4738 {
4739 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
4740 }
4741 parsingData->PopContext(Id());
4742 }
4743 public override void Link()
4744 {
4745 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
4746 a0ActionParser->SetAction(A0Action);
4747 NonterminalParser* leftPtrNonterminalParser = GetNonterminal(ToUtf32("leftPtr"));
4748 leftPtrNonterminalParser->SetPre(PreleftPtr);
4749 leftPtrNonterminalParser->SetPost(PostleftPtr);
4750 NonterminalParser* rightPtrNonterminalParser = GetNonterminal(ToUtf32("rightPtr"));
4751 rightPtrNonterminalParser->SetPre(PrerightPtr);
4752 rightPtrNonterminalParser->SetPost(PostrightPtr);
4753 }
4754 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4755 {
4756 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4757 context->value = new PtrDiffInstruction(context->result, context->fromleftPtr, context->fromrightPtr, span.lineNumber);
4758 }
4759 public void PreleftPtr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4760 {
4761 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4762 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
4763 }
4764 public void PostleftPtr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4765 {
4766 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4767 if (matched)
4768 {
4769 UniquePtr<Object> fromleftPtr_value = stack.Pop();
4770 context->fromleftPtr = *cast<ValueObject<Value*>*>(fromleftPtr_value.Get());
4771 }
4772 }
4773 public void PrerightPtr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4774 {
4775 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4776 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
4777 }
4778 public void PostrightPtr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4779 {
4780 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4781 if (matched)
4782 {
4783 UniquePtr<Object> fromrightPtr_value = stack.Pop();
4784 context->fromrightPtr = *cast<ValueObject<Value*>*>(fromrightPtr_value.Get());
4785 }
4786 }
4787 public class Context : System.Text.Parsing.Context
4788 {
4789 public Context() : context(), result(), value(), fromleftPtr(), fromrightPtr()
4790 {
4791 }
4792 public cmsx.intermediate.Context* context;
4793 public Value* result;
4794 public Instruction* value;
4795 public Value* fromleftPtr;
4796 public Value* fromrightPtr;
4797 }
4798 }
4799
4800 public class FunctionCallInstructionRule : System.Text.Parsing.RuleParser
4801 {
4802 public FunctionCallInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
4803 {
4804 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
4805 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
4806 SetValueTypeName(ToUtf32("Instruction*"));
4807 }
4808 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4809 {
4810 parsingData->PushContext(Id(), new Context());
4811 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4812 UniquePtr<Object> result_value = stack.Pop();
4813 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
4814 UniquePtr<Object> context_value = stack.Pop();
4815 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
4816 }
4817 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4818 {
4819 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4820 if (matched)
4821 {
4822 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
4823 }
4824 parsingData->PopContext(Id());
4825 }
4826 public override void Link()
4827 {
4828 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
4829 a0ActionParser->SetAction(A0Action);
4830 NonterminalParser* functionTypeNonterminalParser = GetNonterminal(ToUtf32("functionType"));
4831 functionTypeNonterminalParser->SetPre(PrefunctionType);
4832 functionTypeNonterminalParser->SetPost(PostfunctionType);
4833 NonterminalParser* calleeNonterminalParser = GetNonterminal(ToUtf32("callee"));
4834 calleeNonterminalParser->SetPre(Precallee);
4835 calleeNonterminalParser->SetPost(Postcallee);
4836 }
4837 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4838 {
4839 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4840 context->value = new FunctionCallInstruction(context->result, context->fromcallee, span.lineNumber);
4841 }
4842 public void PrefunctionType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4843 {
4844 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4845 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
4846 }
4847 public void PostfunctionType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4848 {
4849 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4850 if (matched)
4851 {
4852 UniquePtr<Object> fromfunctionType_value = stack.Pop();
4853 context->fromfunctionType = *cast<ValueObject<Type*>*>(fromfunctionType_value.Get());
4854 }
4855 }
4856 public void Precallee(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4857 {
4858 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4859 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
4860 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->fromfunctionType)));
4861 }
4862 public void Postcallee(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4863 {
4864 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4865 if (matched)
4866 {
4867 UniquePtr<Object> fromcallee_value = stack.Pop();
4868 context->fromcallee = *cast<ValueObject<Value*>*>(fromcallee_value.Get());
4869 }
4870 }
4871 public class Context : System.Text.Parsing.Context
4872 {
4873 public Context() : context(), result(), value(), fromfunctionType(), fromcallee()
4874 {
4875 }
4876 public cmsx.intermediate.Context* context;
4877 public Value* result;
4878 public Instruction* value;
4879 public Type* fromfunctionType;
4880 public Value* fromcallee;
4881 }
4882 }
4883
4884 public class TrapInstructionRule : System.Text.Parsing.RuleParser
4885 {
4886 public TrapInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
4887 {
4888 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
4889 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
4890 SetValueTypeName(ToUtf32("Instruction*"));
4891 }
4892 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4893 {
4894 parsingData->PushContext(Id(), new Context());
4895 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4896 UniquePtr<Object> result_value = stack.Pop();
4897 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
4898 UniquePtr<Object> context_value = stack.Pop();
4899 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
4900 }
4901 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4902 {
4903 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4904 if (matched)
4905 {
4906 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
4907 }
4908 parsingData->PopContext(Id());
4909 }
4910 public override void Link()
4911 {
4912 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
4913 a0ActionParser->SetAction(A0Action);
4914 NonterminalParser* type1NonterminalParser = GetNonterminal(ToUtf32("type1"));
4915 type1NonterminalParser->SetPre(Pretype1);
4916 type1NonterminalParser->SetPost(Posttype1);
4917 NonterminalParser* val1NonterminalParser = GetNonterminal(ToUtf32("val1"));
4918 val1NonterminalParser->SetPre(Preval1);
4919 val1NonterminalParser->SetPost(Postval1);
4920 NonterminalParser* type2NonterminalParser = GetNonterminal(ToUtf32("type2"));
4921 type2NonterminalParser->SetPre(Pretype2);
4922 type2NonterminalParser->SetPost(Posttype2);
4923 NonterminalParser* val2NonterminalParser = GetNonterminal(ToUtf32("val2"));
4924 val2NonterminalParser->SetPre(Preval2);
4925 val2NonterminalParser->SetPost(Postval2);
4926 NonterminalParser* type3NonterminalParser = GetNonterminal(ToUtf32("type3"));
4927 type3NonterminalParser->SetPre(Pretype3);
4928 type3NonterminalParser->SetPost(Posttype3);
4929 NonterminalParser* val3NonterminalParser = GetNonterminal(ToUtf32("val3"));
4930 val3NonterminalParser->SetPre(Preval3);
4931 val3NonterminalParser->SetPost(Postval3);
4932 }
4933 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4934 {
4935 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4936 context->value = new TrapInstruction(context->result, context->fromval1, context->fromval2, context->fromval3, span.lineNumber);
4937 }
4938 public void Pretype1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4939 {
4940 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4941 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
4942 }
4943 public void Posttype1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4944 {
4945 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4946 if (matched)
4947 {
4948 UniquePtr<Object> fromtype1_value = stack.Pop();
4949 context->fromtype1 = *cast<ValueObject<Type*>*>(fromtype1_value.Get());
4950 }
4951 }
4952 public void Preval1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4953 {
4954 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4955 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
4956 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->fromtype1)));
4957 }
4958 public void Postval1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4959 {
4960 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4961 if (matched)
4962 {
4963 UniquePtr<Object> fromval1_value = stack.Pop();
4964 context->fromval1 = *cast<ValueObject<Value*>*>(fromval1_value.Get());
4965 }
4966 }
4967 public void Pretype2(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4968 {
4969 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4970 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
4971 }
4972 public void Posttype2(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4973 {
4974 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4975 if (matched)
4976 {
4977 UniquePtr<Object> fromtype2_value = stack.Pop();
4978 context->fromtype2 = *cast<ValueObject<Type*>*>(fromtype2_value.Get());
4979 }
4980 }
4981 public void Preval2(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4982 {
4983 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4984 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
4985 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->fromtype2)));
4986 }
4987 public void Postval2(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4988 {
4989 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4990 if (matched)
4991 {
4992 UniquePtr<Object> fromval2_value = stack.Pop();
4993 context->fromval2 = *cast<ValueObject<Value*>*>(fromval2_value.Get());
4994 }
4995 }
4996 public void Pretype3(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4997 {
4998 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4999 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
5000 }
5001 public void Posttype3(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5002 {
5003 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5004 if (matched)
5005 {
5006 UniquePtr<Object> fromtype3_value = stack.Pop();
5007 context->fromtype3 = *cast<ValueObject<Type*>*>(fromtype3_value.Get());
5008 }
5009 }
5010 public void Preval3(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
5011 {
5012 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5013 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
5014 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->fromtype3)));
5015 }
5016 public void Postval3(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5017 {
5018 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5019 if (matched)
5020 {
5021 UniquePtr<Object> fromval3_value = stack.Pop();
5022 context->fromval3 = *cast<ValueObject<Value*>*>(fromval3_value.Get());
5023 }
5024 }
5025 public class Context : System.Text.Parsing.Context
5026 {
5027 public Context() : context(), result(), value(), fromtype1(), fromval1(), fromtype2(), fromval2(), fromtype3(), fromval3()
5028 {
5029 }
5030 public cmsx.intermediate.Context* context;
5031 public Value* result;
5032 public Instruction* value;
5033 public Type* fromtype1;
5034 public Value* fromval1;
5035 public Type* fromtype2;
5036 public Value* fromval2;
5037 public Type* fromtype3;
5038 public Value* fromval3;
5039 }
5040 }
5041
5042 public class OperandRule : System.Text.Parsing.RuleParser
5043 {
5044 public OperandRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
5045 {
5046 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
5047 SetValueTypeName(ToUtf32("Value*"));
5048 }
5049 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
5050 {
5051 parsingData->PushContext(Id(), new Context());
5052 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5053 UniquePtr<Object> context_value = stack.Pop();
5054 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
5055 }
5056 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5057 {
5058 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5059 if (matched)
5060 {
5061 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->value)));
5062 }
5063 parsingData->PopContext(Id());
5064 }
5065 public override void Link()
5066 {
5067 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
5068 a0ActionParser->SetAction(A0Action);
5069 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
5070 typeNonterminalParser->SetPre(Pretype);
5071 typeNonterminalParser->SetPost(Posttype);
5072 NonterminalParser* valNonterminalParser = GetNonterminal(ToUtf32("val"));
5073 valNonterminalParser->SetPre(Preval);
5074 valNonterminalParser->SetPost(Postval);
5075 }
5076 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
5077 {
5078 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5079 context->value = context->fromval;
5080 }
5081 public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
5082 {
5083 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5084 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
5085 }
5086 public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5087 {
5088 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5089 if (matched)
5090 {
5091 UniquePtr<Object> fromtype_value = stack.Pop();
5092 context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
5093 }
5094 }
5095 public void Preval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
5096 {
5097 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5098 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
5099 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->fromtype)));
5100 }
5101 public void Postval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5102 {
5103 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5104 if (matched)
5105 {
5106 UniquePtr<Object> fromval_value = stack.Pop();
5107 context->fromval = *cast<ValueObject<Value*>*>(fromval_value.Get());
5108 }
5109 }
5110 public class Context : System.Text.Parsing.Context
5111 {
5112 public Context() : context(), value(), fromtype(), fromval()
5113 {
5114 }
5115 public cmsx.intermediate.Context* context;
5116 public Value* value;
5117 public Type* fromtype;
5118 public Value* fromval;
5119 }
5120 }
5121
5122 public class LabelRule : System.Text.Parsing.RuleParser
5123 {
5124 public LabelRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
5125 {
5126 SetValueTypeName(ToUtf32("uint"));
5127 }
5128 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
5129 {
5130 parsingData->PushContext(Id(), new Context());
5131 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5132 }
5133 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5134 {
5135 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5136 if (matched)
5137 {
5138 stack.Push(UniquePtr<Object>(new ValueObject<uint>(context->value)));
5139 }
5140 parsingData->PopContext(Id());
5141 }
5142 public override void Link()
5143 {
5144 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
5145 a0ActionParser->SetAction(A0Action);
5146 NonterminalParser* xNonterminalParser = GetNonterminal(ToUtf32("x"));
5147 xNonterminalParser->SetPost(Postx);
5148 }
5149 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
5150 {
5151 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5152 context->value = context->fromx;
5153 }
5154 public void Postx(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5155 {
5156 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5157 if (matched)
5158 {
5159 UniquePtr<Object> fromx_value = stack.Pop();
5160 context->fromx = *cast<ValueObject<uint>*>(fromx_value.Get());
5161 }
5162 }
5163 public class Context : System.Text.Parsing.Context
5164 {
5165 public Context() : value(), fromx()
5166 {
5167 }
5168 public uint value;
5169 public uint fromx;
5170 }
5171 }
5172
5173 public class ValueRule : System.Text.Parsing.RuleParser
5174 {
5175 public ValueRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
5176 {
5177 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
5178 AddInheritedAttribute(AttrOrVar(ToUtf32("Type*"), ToUtf32("type")));
5179 SetValueTypeName(ToUtf32("Value*"));
5180 }
5181 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
5182 {
5183 parsingData->PushContext(Id(), new Context());
5184 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5185 UniquePtr<Object> type_value = stack.Pop();
5186 context->type = *cast<ValueObject<Type*>*>(type_value.Get());
5187 UniquePtr<Object> context_value = stack.Pop();
5188 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
5189 }
5190 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5191 {
5192 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5193 if (matched)
5194 {
5195 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->value)));
5196 }
5197 parsingData->PopContext(Id());
5198 }
5199 public override void Link()
5200 {
5201 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
5202 a0ActionParser->SetAction(A0Action);
5203 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
5204 a1ActionParser->SetAction(A1Action);
5205 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
5206 a2ActionParser->SetAction(A2Action);
5207 NonterminalParser* idValueNonterminalParser = GetNonterminal(ToUtf32("IdValue"));
5208 idValueNonterminalParser->SetPre(PreIdValue);
5209 idValueNonterminalParser->SetPost(PostIdValue);
5210 NonterminalParser* symbolValueNonterminalParser = GetNonterminal(ToUtf32("SymbolValue"));
5211 symbolValueNonterminalParser->SetPre(PreSymbolValue);
5212 symbolValueNonterminalParser->SetPost(PostSymbolValue);
5213 NonterminalParser* literalValueNonterminalParser = GetNonterminal(ToUtf32("LiteralValue"));
5214 literalValueNonterminalParser->SetPre(PreLiteralValue);
5215 literalValueNonterminalParser->SetPost(PostLiteralValue);
5216 }
5217 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
5218 {
5219 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5220 context->value = context->fromIdValue;
5221 }
5222 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
5223 {
5224 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5225 context->value = context->fromSymbolValue;
5226 }
5227 public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
5228 {
5229 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5230 context->value = context->fromLiteralValue;
5231 }
5232 public void PreIdValue(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
5233 {
5234 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5235 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
5236 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->type)));
5237 }
5238 public void PostIdValue(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5239 {
5240 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5241 if (matched)
5242 {
5243 UniquePtr<Object> fromIdValue_value = stack.Pop();
5244 context->fromIdValue = *cast<ValueObject<Value*>*>(fromIdValue_value.Get());
5245 }
5246 }
5247 public void PreSymbolValue(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
5248 {
5249 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5250 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
5251 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->type)));
5252 }
5253 public void PostSymbolValue(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5254 {
5255 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5256 if (matched)
5257 {
5258 UniquePtr<Object> fromSymbolValue_value = stack.Pop();
5259 context->fromSymbolValue = *cast<ValueObject<ConstantValue*>*>(fromSymbolValue_value.Get());
5260 }
5261 }
5262 public void PreLiteralValue(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
5263 {
5264 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5265 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
5266 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->type)));
5267 }
5268 public void PostLiteralValue(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5269 {
5270 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5271 if (matched)
5272 {
5273 UniquePtr<Object> fromLiteralValue_value = stack.Pop();
5274 context->fromLiteralValue = *cast<ValueObject<ConstantValue*>*>(fromLiteralValue_value.Get());
5275 }
5276 }
5277 public class Context : System.Text.Parsing.Context
5278 {
5279 public Context() : context(), type(), value(), fromIdValue(), fromSymbolValue(), fromLiteralValue()
5280 {
5281 }
5282 public cmsx.intermediate.Context* context;
5283 public Type* type;
5284 public Value* value;
5285 public Value* fromIdValue;
5286 public ConstantValue* fromSymbolValue;
5287 public ConstantValue* fromLiteralValue;
5288 }
5289 }
5290
5291 public class IdValueRule : System.Text.Parsing.RuleParser
5292 {
5293 public IdValueRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
5294 {
5295 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
5296 AddInheritedAttribute(AttrOrVar(ToUtf32("Type*"), ToUtf32("type")));
5297 SetValueTypeName(ToUtf32("Value*"));
5298 }
5299 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
5300 {
5301 parsingData->PushContext(Id(), new Context());
5302 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5303 UniquePtr<Object> type_value = stack.Pop();
5304 context->type = *cast<ValueObject<Type*>*>(type_value.Get());
5305 UniquePtr<Object> context_value = stack.Pop();
5306 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
5307 }
5308 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5309 {
5310 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5311 if (matched)
5312 {
5313 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->value)));
5314 }
5315 parsingData->PopContext(Id());
5316 }
5317 public override void Link()
5318 {
5319 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
5320 a0ActionParser->SetAction(A0Action);
5321 NonterminalParser* xNonterminalParser = GetNonterminal(ToUtf32("x"));
5322 xNonterminalParser->SetPost(Postx);
5323 }
5324 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
5325 {
5326 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5327 context->value = context->context->currentFunction->MakeIdValue(span.lineNumber, context->fromx, context->type);
5328 }
5329 public void Postx(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5330 {
5331 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5332 if (matched)
5333 {
5334 UniquePtr<Object> fromx_value = stack.Pop();
5335 context->fromx = *cast<ValueObject<uint>*>(fromx_value.Get());
5336 }
5337 }
5338 public class Context : System.Text.Parsing.Context
5339 {
5340 public Context() : context(), type(), value(), fromx()
5341 {
5342 }
5343 public cmsx.intermediate.Context* context;
5344 public Type* type;
5345 public Value* value;
5346 public uint fromx;
5347 }
5348 }
5349
5350 public class SymbolValueRule : System.Text.Parsing.RuleParser
5351 {
5352 public SymbolValueRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
5353 {
5354 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
5355 AddInheritedAttribute(AttrOrVar(ToUtf32("Type*"), ToUtf32("type")));
5356 SetValueTypeName(ToUtf32("ConstantValue*"));
5357 }
5358 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
5359 {
5360 parsingData->PushContext(Id(), new Context());
5361 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5362 UniquePtr<Object> type_value = stack.Pop();
5363 context->type = *cast<ValueObject<Type*>*>(type_value.Get());
5364 UniquePtr<Object> context_value = stack.Pop();
5365 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
5366 }
5367 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5368 {
5369 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5370 if (matched)
5371 {
5372 stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
5373 }
5374 parsingData->PopContext(Id());
5375 }
5376 public override void Link()
5377 {
5378 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
5379 a0ActionParser->SetAction(A0Action);
5380 NonterminalParser* identifierNonterminalParser = GetNonterminal(ToUtf32("identifier"));
5381 identifierNonterminalParser->SetPost(Postidentifier);
5382 }
5383 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
5384 {
5385 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5386 context->value = context->context->MakeSymbolValue(span.lineNumber, ToUtf8(context->fromidentifier), context->type);
5387 }
5388 public void Postidentifier(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5389 {
5390 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5391 if (matched)
5392 {
5393 UniquePtr<Object> fromidentifier_value = stack.Pop();
5394 context->fromidentifier = *cast<ValueObject<ustring>*>(fromidentifier_value.Get());
5395 }
5396 }
5397 public class Context : System.Text.Parsing.Context
5398 {
5399 public Context() : context(), type(), value(), fromidentifier()
5400 {
5401 }
5402 public cmsx.intermediate.Context* context;
5403 public Type* type;
5404 public ConstantValue* value;
5405 public ustring fromidentifier;
5406 }
5407 }
5408
5409 public class LiteralValueRule : System.Text.Parsing.RuleParser
5410 {
5411 public LiteralValueRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
5412 {
5413 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
5414 AddInheritedAttribute(AttrOrVar(ToUtf32("Type*"), ToUtf32("type")));
5415 SetValueTypeName(ToUtf32("ConstantValue*"));
5416 }
5417 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
5418 {
5419 parsingData->PushContext(Id(), new Context());
5420 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5421 UniquePtr<Object> type_value = stack.Pop();
5422 context->type = *cast<ValueObject<Type*>*>(type_value.Get());
5423 UniquePtr<Object> context_value = stack.Pop();
5424 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
5425 }
5426 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5427 {
5428 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5429 if (matched)
5430 {
5431 stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
5432 }
5433 parsingData->PopContext(Id());
5434 }
5435 public override void Link()
5436 {
5437 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
5438 a0ActionParser->SetAction(A0Action);
5439 }
5440 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
5441 {
5442 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5443 context->value = context->context->MakeLiteralValue(span.lineNumber, ToUtf8(ustring(matchBegin, matchEnd)), context->type);
5444 }
5445 public class Context : System.Text.Parsing.Context
5446 {
5447 public Context() : context(), type(), value()
5448 {
5449 }
5450 public cmsx.intermediate.Context* context;
5451 public Type* type;
5452 public ConstantValue* value;
5453 }
5454 }
5455
5456 public class VariableNameRule : System.Text.Parsing.RuleParser
5457 {
5458 public VariableNameRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
5459 {
5460 SetValueTypeName(ToUtf32("ustring"));
5461 }
5462 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
5463 {
5464 parsingData->PushContext(Id(), new Context());
5465 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5466 }
5467 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5468 {
5469 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5470 if (matched)
5471 {
5472 stack.Push(UniquePtr<Object>(new ValueObject<ustring>(context->value)));
5473 }
5474 parsingData->PopContext(Id());
5475 }
5476 public override void Link()
5477 {
5478 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
5479 a0ActionParser->SetAction(A0Action);
5480 }
5481 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
5482 {
5483 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5484 context->value = ustring(matchBegin, matchEnd);
5485 }
5486 public class Context : System.Text.Parsing.Context
5487 {
5488 public Context() : value()
5489 {
5490 }
5491 public ustring value;
5492 }
5493 }
5494
5495 public class TypeDeclarationRule : System.Text.Parsing.RuleParser
5496 {
5497 public TypeDeclarationRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
5498 {
5499 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
5500 }
5501 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
5502 {
5503 parsingData->PushContext(Id(), new Context());
5504 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5505 UniquePtr<Object> context_value = stack.Pop();
5506 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
5507 }
5508 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5509 {
5510 parsingData->PopContext(Id());
5511 }
5512 public override void Link()
5513 {
5514 NonterminalParser* typeIdNonterminalParser = GetNonterminal(ToUtf32("typeId"));
5515 typeIdNonterminalParser->SetPre(PretypeId);
5516 typeIdNonterminalParser->SetPost(PosttypeId);
5517 NonterminalParser* structureTypeNonterminalParser = GetNonterminal(ToUtf32("StructureType"));
5518 structureTypeNonterminalParser->SetPre(PreStructureType);
5519 NonterminalParser* arrayTypeNonterminalParser = GetNonterminal(ToUtf32("ArrayType"));
5520 arrayTypeNonterminalParser->SetPre(PreArrayType);
5521 NonterminalParser* functionTypeNonterminalParser = GetNonterminal(ToUtf32("FunctionType"));
5522 functionTypeNonterminalParser->SetPre(PreFunctionType);
5523 }
5524 public void PretypeId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
5525 {
5526 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5527 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
5528 }
5529 public void PosttypeId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5530 {
5531 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5532 if (matched)
5533 {
5534 UniquePtr<Object> fromtypeId_value = stack.Pop();
5535 context->fromtypeId = *cast<ValueObject<string>*>(fromtypeId_value.Get());
5536 }
5537 }
5538 public void PreStructureType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
5539 {
5540 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5541 stack.Push(UniquePtr<Object>(new ValueObject<string>(context->fromtypeId)));
5542 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
5543 }
5544 public void PreArrayType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
5545 {
5546 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5547 stack.Push(UniquePtr<Object>(new ValueObject<string>(context->fromtypeId)));
5548 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
5549 }
5550 public void PreFunctionType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
5551 {
5552 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5553 stack.Push(UniquePtr<Object>(new ValueObject<string>(context->fromtypeId)));
5554 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
5555 }
5556 public class Context : System.Text.Parsing.Context
5557 {
5558 public Context() : context(), fromtypeId()
5559 {
5560 }
5561 public cmsx.intermediate.Context* context;
5562 public string fromtypeId;
5563 }
5564 }
5565
5566 public class StructureTypeRule : System.Text.Parsing.RuleParser
5567 {
5568 public StructureTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
5569 {
5570 AddInheritedAttribute(AttrOrVar(ToUtf32("string"), ToUtf32("typeId")));
5571 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
5572 AddLocalVariable(AttrOrVar(ToUtf32("List<string>"), ToUtf32("memberTypeIds")));
5573 }
5574 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
5575 {
5576 parsingData->PushContext(Id(), new Context());
5577 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5578 UniquePtr<Object> context_value = stack.Pop();
5579 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
5580 UniquePtr<Object> typeId_value = stack.Pop();
5581 context->typeId = *cast<ValueObject<string>*>(typeId_value.Get());
5582 }
5583 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5584 {
5585 parsingData->PopContext(Id());
5586 }
5587 public override void Link()
5588 {
5589 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
5590 a0ActionParser->SetAction(A0Action);
5591 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
5592 a1ActionParser->SetAction(A1Action);
5593 NonterminalParser* strTypeIdNonterminalParser = GetNonterminal(ToUtf32("StrTypeId"));
5594 strTypeIdNonterminalParser->SetPre(PreStrTypeId);
5595 strTypeIdNonterminalParser->SetPost(PostStrTypeId);
5596 NonterminalParser* longNonterminalParser = GetNonterminal(ToUtf32("long"));
5597 longNonterminalParser->SetPost(Postlong);
5598 NonterminalParser* szNonterminalParser = GetNonterminal(ToUtf32("sz"));
5599 szNonterminalParser->SetPost(Postsz);
5600 NonterminalParser* alNonterminalParser = GetNonterminal(ToUtf32("al"));
5601 alNonterminalParser->SetPost(Postal);
5602 }
5603 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
5604 {
5605 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5606 context->context->AddStructureType(context->typeId, context->memberTypeIds);
5607 }
5608 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
5609 {
5610 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5611 context->memberTypeIds.Add(context->fromStrTypeId);
5612 }
5613 public void PreStrTypeId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
5614 {
5615 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5616 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
5617 }
5618 public void PostStrTypeId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5619 {
5620 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5621 if (matched)
5622 {
5623 UniquePtr<Object> fromStrTypeId_value = stack.Pop();
5624 context->fromStrTypeId = *cast<ValueObject<string>*>(fromStrTypeId_value.Get());
5625 }
5626 }
5627 public void Postlong(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5628 {
5629 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5630 if (matched)
5631 {
5632 UniquePtr<Object> fromlong_value = stack.Pop();
5633 context->fromlong = *cast<ValueObject<long>*>(fromlong_value.Get());
5634 }
5635 }
5636 public void Postsz(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5637 {
5638 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5639 if (matched)
5640 {
5641 UniquePtr<Object> fromsz_value = stack.Pop();
5642 context->fromsz = *cast<ValueObject<long>*>(fromsz_value.Get());
5643 }
5644 }
5645 public void Postal(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5646 {
5647 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5648 if (matched)
5649 {
5650 UniquePtr<Object> fromal_value = stack.Pop();
5651 context->fromal = *cast<ValueObject<long>*>(fromal_value.Get());
5652 }
5653 }
5654 public class Context : System.Text.Parsing.Context
5655 {
5656 public Context() : typeId(), context(), memberTypeIds(), fromStrTypeId(), fromlong(), fromsz(), fromal()
5657 {
5658 }
5659 public string typeId;
5660 public cmsx.intermediate.Context* context;
5661 public List<string> memberTypeIds;
5662 public string fromStrTypeId;
5663 public long fromlong;
5664 public long fromsz;
5665 public long fromal;
5666 }
5667 }
5668
5669 public class ArrayTypeRule : System.Text.Parsing.RuleParser
5670 {
5671 public ArrayTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
5672 {
5673 AddInheritedAttribute(AttrOrVar(ToUtf32("string"), ToUtf32("typeId")));
5674 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
5675 }
5676 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
5677 {
5678 parsingData->PushContext(Id(), new Context());
5679 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5680 UniquePtr<Object> context_value = stack.Pop();
5681 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
5682 UniquePtr<Object> typeId_value = stack.Pop();
5683 context->typeId = *cast<ValueObject<string>*>(typeId_value.Get());
5684 }
5685 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5686 {
5687 parsingData->PopContext(Id());
5688 }
5689 public override void Link()
5690 {
5691 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
5692 a0ActionParser->SetAction(A0Action);
5693 NonterminalParser* sizeNonterminalParser = GetNonterminal(ToUtf32("size"));
5694 sizeNonterminalParser->SetPost(Postsize);
5695 NonterminalParser* elementTypeIdNonterminalParser = GetNonterminal(ToUtf32("elementTypeId"));
5696 elementTypeIdNonterminalParser->SetPre(PreelementTypeId);
5697 elementTypeIdNonterminalParser->SetPost(PostelementTypeId);
5698 NonterminalParser* szNonterminalParser = GetNonterminal(ToUtf32("sz"));
5699 szNonterminalParser->SetPost(Postsz);
5700 NonterminalParser* alNonterminalParser = GetNonterminal(ToUtf32("al"));
5701 alNonterminalParser->SetPost(Postal);
5702 }
5703 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
5704 {
5705 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5706 context->context->AddArrayType(context->typeId, context->fromelementTypeId, context->fromsize);
5707 }
5708 public void Postsize(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5709 {
5710 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5711 if (matched)
5712 {
5713 UniquePtr<Object> fromsize_value = stack.Pop();
5714 context->fromsize = *cast<ValueObject<long>*>(fromsize_value.Get());
5715 }
5716 }
5717 public void PreelementTypeId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
5718 {
5719 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5720 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
5721 }
5722 public void PostelementTypeId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5723 {
5724 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5725 if (matched)
5726 {
5727 UniquePtr<Object> fromelementTypeId_value = stack.Pop();
5728 context->fromelementTypeId = *cast<ValueObject<string>*>(fromelementTypeId_value.Get());
5729 }
5730 }
5731 public void Postsz(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5732 {
5733 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5734 if (matched)
5735 {
5736 UniquePtr<Object> fromsz_value = stack.Pop();
5737 context->fromsz = *cast<ValueObject<long>*>(fromsz_value.Get());
5738 }
5739 }
5740 public void Postal(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5741 {
5742 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5743 if (matched)
5744 {
5745 UniquePtr<Object> fromal_value = stack.Pop();
5746 context->fromal = *cast<ValueObject<long>*>(fromal_value.Get());
5747 }
5748 }
5749 public class Context : System.Text.Parsing.Context
5750 {
5751 public Context() : typeId(), context(), fromsize(), fromelementTypeId(), fromsz(), fromal()
5752 {
5753 }
5754 public string typeId;
5755 public cmsx.intermediate.Context* context;
5756 public long fromsize;
5757 public string fromelementTypeId;
5758 public long fromsz;
5759 public long fromal;
5760 }
5761 }
5762
5763 public class FunctionTypeRule : System.Text.Parsing.RuleParser
5764 {
5765 public FunctionTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
5766 {
5767 AddInheritedAttribute(AttrOrVar(ToUtf32("string"), ToUtf32("typeId")));
5768 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
5769 AddLocalVariable(AttrOrVar(ToUtf32("List<string>"), ToUtf32("paramTypeIds")));
5770 }
5771 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
5772 {
5773 parsingData->PushContext(Id(), new Context());
5774 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5775 UniquePtr<Object> context_value = stack.Pop();
5776 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
5777 UniquePtr<Object> typeId_value = stack.Pop();
5778 context->typeId = *cast<ValueObject<string>*>(typeId_value.Get());
5779 }
5780 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5781 {
5782 parsingData->PopContext(Id());
5783 }
5784 public override void Link()
5785 {
5786 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
5787 a0ActionParser->SetAction(A0Action);
5788 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
5789 a1ActionParser->SetAction(A1Action);
5790 NonterminalParser* returnTypeIdNonterminalParser = GetNonterminal(ToUtf32("returnTypeId"));
5791 returnTypeIdNonterminalParser->SetPre(PrereturnTypeId);
5792 returnTypeIdNonterminalParser->SetPost(PostreturnTypeId);
5793 NonterminalParser* paramTypeNonterminalParser = GetNonterminal(ToUtf32("paramType"));
5794 paramTypeNonterminalParser->SetPre(PreparamType);
5795 paramTypeNonterminalParser->SetPost(PostparamType);
5796 }
5797 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
5798 {
5799 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5800 context->context->AddFunctionType(context->typeId, context->fromreturnTypeId, context->paramTypeIds);
5801 }
5802 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
5803 {
5804 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5805 context->paramTypeIds.Add(context->fromparamType);
5806 }
5807 public void PrereturnTypeId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
5808 {
5809 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5810 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
5811 }
5812 public void PostreturnTypeId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5813 {
5814 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5815 if (matched)
5816 {
5817 UniquePtr<Object> fromreturnTypeId_value = stack.Pop();
5818 context->fromreturnTypeId = *cast<ValueObject<string>*>(fromreturnTypeId_value.Get());
5819 }
5820 }
5821 public void PreparamType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
5822 {
5823 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5824 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
5825 }
5826 public void PostparamType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5827 {
5828 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5829 if (matched)
5830 {
5831 UniquePtr<Object> fromparamType_value = stack.Pop();
5832 context->fromparamType = *cast<ValueObject<string>*>(fromparamType_value.Get());
5833 }
5834 }
5835 public class Context : System.Text.Parsing.Context
5836 {
5837 public Context() : typeId(), context(), paramTypeIds(), fromreturnTypeId(), fromparamType()
5838 {
5839 }
5840 public string typeId;
5841 public cmsx.intermediate.Context* context;
5842 public List<string> paramTypeIds;
5843 public string fromreturnTypeId;
5844 public string fromparamType;
5845 }
5846 }
5847
5848 public class StrTypeIdRule : System.Text.Parsing.RuleParser
5849 {
5850 public StrTypeIdRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
5851 {
5852 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
5853 SetValueTypeName(ToUtf32("string"));
5854 }
5855 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
5856 {
5857 parsingData->PushContext(Id(), new Context());
5858 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5859 UniquePtr<Object> context_value = stack.Pop();
5860 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
5861 }
5862 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5863 {
5864 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5865 if (matched)
5866 {
5867 stack.Push(UniquePtr<Object>(new ValueObject<string>(context->value)));
5868 }
5869 parsingData->PopContext(Id());
5870 }
5871 public override void Link()
5872 {
5873 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
5874 a0ActionParser->SetAction(A0Action);
5875 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
5876 a1ActionParser->SetAction(A1Action);
5877 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
5878 a2ActionParser->SetAction(A2Action);
5879 NonterminalParser* uintNonterminalParser = GetNonterminal(ToUtf32("uint"));
5880 uintNonterminalParser->SetPost(Postuint);
5881 }
5882 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
5883 {
5884 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5885 context->value = ToUtf8(ustring(matchBegin, matchEnd));
5886 }
5887 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
5888 {
5889 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5890 context->value = ToUtf8(ustring(matchBegin, matchEnd));
5891 }
5892 public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
5893 {
5894 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5895 context->value.Append('*');
5896 context->context->AddPtrType(context->value, span.lineNumber);
5897 }
5898 public void Postuint(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5899 {
5900 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5901 if (matched)
5902 {
5903 UniquePtr<Object> fromuint_value = stack.Pop();
5904 context->fromuint = *cast<ValueObject<uint>*>(fromuint_value.Get());
5905 }
5906 }
5907 public class Context : System.Text.Parsing.Context
5908 {
5909 public Context() : context(), value(), fromuint()
5910 {
5911 }
5912 public cmsx.intermediate.Context* context;
5913 public string value;
5914 public uint fromuint;
5915 }
5916 }
5917
5918 public class TypeExprRule : System.Text.Parsing.RuleParser
5919 {
5920 public TypeExprRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
5921 {
5922 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
5923 SetValueTypeName(ToUtf32("Type*"));
5924 }
5925 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
5926 {
5927 parsingData->PushContext(Id(), new Context());
5928 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5929 UniquePtr<Object> context_value = stack.Pop();
5930 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
5931 }
5932 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5933 {
5934 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5935 if (matched)
5936 {
5937 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
5938 }
5939 parsingData->PopContext(Id());
5940 }
5941 public override void Link()
5942 {
5943 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
5944 a0ActionParser->SetAction(A0Action);
5945 NonterminalParser* postfixTypeExprNonterminalParser = GetNonterminal(ToUtf32("PostfixTypeExpr"));
5946 postfixTypeExprNonterminalParser->SetPre(PrePostfixTypeExpr);
5947 postfixTypeExprNonterminalParser->SetPost(PostPostfixTypeExpr);
5948 }
5949 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
5950 {
5951 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5952 context->value = context->fromPostfixTypeExpr;
5953 }
5954 public void PrePostfixTypeExpr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
5955 {
5956 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5957 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
5958 }
5959 public void PostPostfixTypeExpr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5960 {
5961 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5962 if (matched)
5963 {
5964 UniquePtr<Object> fromPostfixTypeExpr_value = stack.Pop();
5965 context->fromPostfixTypeExpr = *cast<ValueObject<Type*>*>(fromPostfixTypeExpr_value.Get());
5966 }
5967 }
5968 public class Context : System.Text.Parsing.Context
5969 {
5970 public Context() : context(), value(), fromPostfixTypeExpr()
5971 {
5972 }
5973 public cmsx.intermediate.Context* context;
5974 public Type* value;
5975 public Type* fromPostfixTypeExpr;
5976 }
5977 }
5978
5979 public class PostfixTypeExprRule : System.Text.Parsing.RuleParser
5980 {
5981 public PostfixTypeExprRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
5982 {
5983 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
5984 SetValueTypeName(ToUtf32("Type*"));
5985 }
5986 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
5987 {
5988 parsingData->PushContext(Id(), new Context());
5989 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5990 UniquePtr<Object> context_value = stack.Pop();
5991 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
5992 }
5993 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5994 {
5995 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5996 if (matched)
5997 {
5998 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
5999 }
6000 parsingData->PopContext(Id());
6001 }
6002 public override void Link()
6003 {
6004 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
6005 a0ActionParser->SetAction(A0Action);
6006 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
6007 a1ActionParser->SetAction(A1Action);
6008 NonterminalParser* primaryTypeExprNonterminalParser = GetNonterminal(ToUtf32("PrimaryTypeExpr"));
6009 primaryTypeExprNonterminalParser->SetPre(PrePrimaryTypeExpr);
6010 primaryTypeExprNonterminalParser->SetPost(PostPrimaryTypeExpr);
6011 }
6012 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
6013 {
6014 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6015 context->value = context->fromPrimaryTypeExpr;
6016 }
6017 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
6018 {
6019 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6020 context->value = context->context->GetPtrType(context->value);
6021 }
6022 public void PrePrimaryTypeExpr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
6023 {
6024 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6025 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
6026 }
6027 public void PostPrimaryTypeExpr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6028 {
6029 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6030 if (matched)
6031 {
6032 UniquePtr<Object> fromPrimaryTypeExpr_value = stack.Pop();
6033 context->fromPrimaryTypeExpr = *cast<ValueObject<Type*>*>(fromPrimaryTypeExpr_value.Get());
6034 }
6035 }
6036 public class Context : System.Text.Parsing.Context
6037 {
6038 public Context() : context(), value(), fromPrimaryTypeExpr()
6039 {
6040 }
6041 public cmsx.intermediate.Context* context;
6042 public Type* value;
6043 public Type* fromPrimaryTypeExpr;
6044 }
6045 }
6046
6047 public class PrimaryTypeExprRule : System.Text.Parsing.RuleParser
6048 {
6049 public PrimaryTypeExprRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
6050 {
6051 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
6052 SetValueTypeName(ToUtf32("Type*"));
6053 }
6054 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
6055 {
6056 parsingData->PushContext(Id(), new Context());
6057 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6058 UniquePtr<Object> context_value = stack.Pop();
6059 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
6060 }
6061 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6062 {
6063 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6064 if (matched)
6065 {
6066 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
6067 }
6068 parsingData->PopContext(Id());
6069 }
6070 public override void Link()
6071 {
6072 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
6073 a0ActionParser->SetAction(A0Action);
6074 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
6075 a1ActionParser->SetAction(A1Action);
6076 NonterminalParser* typeIdNonterminalParser = GetNonterminal(ToUtf32("TypeId"));
6077 typeIdNonterminalParser->SetPre(PreTypeId);
6078 typeIdNonterminalParser->SetPost(PostTypeId);
6079 NonterminalParser* primitiveTypeNonterminalParser = GetNonterminal(ToUtf32("PrimitiveType"));
6080 primitiveTypeNonterminalParser->SetPre(PrePrimitiveType);
6081 primitiveTypeNonterminalParser->SetPost(PostPrimitiveType);
6082 }
6083 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
6084 {
6085 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6086 context->value = context->fromTypeId;
6087 }
6088 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
6089 {
6090 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6091 context->value = context->fromPrimitiveType;
6092 }
6093 public void PreTypeId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
6094 {
6095 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6096 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
6097 }
6098 public void PostTypeId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6099 {
6100 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6101 if (matched)
6102 {
6103 UniquePtr<Object> fromTypeId_value = stack.Pop();
6104 context->fromTypeId = *cast<ValueObject<Type*>*>(fromTypeId_value.Get());
6105 }
6106 }
6107 public void PrePrimitiveType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
6108 {
6109 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6110 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
6111 }
6112 public void PostPrimitiveType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6113 {
6114 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6115 if (matched)
6116 {
6117 UniquePtr<Object> fromPrimitiveType_value = stack.Pop();
6118 context->fromPrimitiveType = *cast<ValueObject<Type*>*>(fromPrimitiveType_value.Get());
6119 }
6120 }
6121 public class Context : System.Text.Parsing.Context
6122 {
6123 public Context() : context(), value(), fromTypeId(), fromPrimitiveType()
6124 {
6125 }
6126 public cmsx.intermediate.Context* context;
6127 public Type* value;
6128 public Type* fromTypeId;
6129 public Type* fromPrimitiveType;
6130 }
6131 }
6132
6133 public class TypeIdRule : System.Text.Parsing.RuleParser
6134 {
6135 public TypeIdRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
6136 {
6137 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
6138 SetValueTypeName(ToUtf32("Type*"));
6139 }
6140 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
6141 {
6142 parsingData->PushContext(Id(), new Context());
6143 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6144 UniquePtr<Object> context_value = stack.Pop();
6145 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
6146 }
6147 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6148 {
6149 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6150 if (matched)
6151 {
6152 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
6153 }
6154 parsingData->PopContext(Id());
6155 }
6156 public override void Link()
6157 {
6158 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
6159 a0ActionParser->SetAction(A0Action);
6160 NonterminalParser* uintNonterminalParser = GetNonterminal(ToUtf32("uint"));
6161 uintNonterminalParser->SetPost(Postuint);
6162 }
6163 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
6164 {
6165 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6166 context->value = context->context->GetTypeById(span.lineNumber, ToUtf8(ustring(matchBegin, matchEnd)));
6167 }
6168 public void Postuint(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6169 {
6170 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6171 if (matched)
6172 {
6173 UniquePtr<Object> fromuint_value = stack.Pop();
6174 context->fromuint = *cast<ValueObject<uint>*>(fromuint_value.Get());
6175 }
6176 }
6177 public class Context : System.Text.Parsing.Context
6178 {
6179 public Context() : context(), value(), fromuint()
6180 {
6181 }
6182 public cmsx.intermediate.Context* context;
6183 public Type* value;
6184 public uint fromuint;
6185 }
6186 }
6187
6188 public class PrimitiveTypeRule : System.Text.Parsing.RuleParser
6189 {
6190 public PrimitiveTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
6191 {
6192 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
6193 SetValueTypeName(ToUtf32("Type*"));
6194 }
6195 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
6196 {
6197 parsingData->PushContext(Id(), new Context());
6198 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6199 UniquePtr<Object> context_value = stack.Pop();
6200 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
6201 }
6202 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6203 {
6204 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6205 if (matched)
6206 {
6207 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
6208 }
6209 parsingData->PopContext(Id());
6210 }
6211 public override void Link()
6212 {
6213 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
6214 a0ActionParser->SetAction(A0Action);
6215 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
6216 a1ActionParser->SetAction(A1Action);
6217 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
6218 a2ActionParser->SetAction(A2Action);
6219 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
6220 a3ActionParser->SetAction(A3Action);
6221 ActionParser* a4ActionParser = GetAction(ToUtf32("A4"));
6222 a4ActionParser->SetAction(A4Action);
6223 ActionParser* a5ActionParser = GetAction(ToUtf32("A5"));
6224 a5ActionParser->SetAction(A5Action);
6225 ActionParser* a6ActionParser = GetAction(ToUtf32("A6"));
6226 a6ActionParser->SetAction(A6Action);
6227 ActionParser* a7ActionParser = GetAction(ToUtf32("A7"));
6228 a7ActionParser->SetAction(A7Action);
6229 ActionParser* a8ActionParser = GetAction(ToUtf32("A8"));
6230 a8ActionParser->SetAction(A8Action);
6231 ActionParser* a9ActionParser = GetAction(ToUtf32("A9"));
6232 a9ActionParser->SetAction(A9Action);
6233 ActionParser* a10ActionParser = GetAction(ToUtf32("A10"));
6234 a10ActionParser->SetAction(A10Action);
6235 ActionParser* a11ActionParser = GetAction(ToUtf32("A11"));
6236 a11ActionParser->SetAction(A11Action);
6237 NonterminalParser* voidTypeNonterminalParser = GetNonterminal(ToUtf32("VoidType"));
6238 voidTypeNonterminalParser->SetPre(PreVoidType);
6239 voidTypeNonterminalParser->SetPost(PostVoidType);
6240 NonterminalParser* boolTypeNonterminalParser = GetNonterminal(ToUtf32("BoolType"));
6241 boolTypeNonterminalParser->SetPre(PreBoolType);
6242 boolTypeNonterminalParser->SetPost(PostBoolType);
6243 NonterminalParser* sByteTypeNonterminalParser = GetNonterminal(ToUtf32("SByteType"));
6244 sByteTypeNonterminalParser->SetPre(PreSByteType);
6245 sByteTypeNonterminalParser->SetPost(PostSByteType);
6246 NonterminalParser* byteTypeNonterminalParser = GetNonterminal(ToUtf32("ByteType"));
6247 byteTypeNonterminalParser->SetPre(PreByteType);
6248 byteTypeNonterminalParser->SetPost(PostByteType);
6249 NonterminalParser* shortTypeNonterminalParser = GetNonterminal(ToUtf32("ShortType"));
6250 shortTypeNonterminalParser->SetPre(PreShortType);
6251 shortTypeNonterminalParser->SetPost(PostShortType);
6252 NonterminalParser* uShortTypeNonterminalParser = GetNonterminal(ToUtf32("UShortType"));
6253 uShortTypeNonterminalParser->SetPre(PreUShortType);
6254 uShortTypeNonterminalParser->SetPost(PostUShortType);
6255 NonterminalParser* intTypeNonterminalParser = GetNonterminal(ToUtf32("IntType"));
6256 intTypeNonterminalParser->SetPre(PreIntType);
6257 intTypeNonterminalParser->SetPost(PostIntType);
6258 NonterminalParser* uIntTypeNonterminalParser = GetNonterminal(ToUtf32("UIntType"));
6259 uIntTypeNonterminalParser->SetPre(PreUIntType);
6260 uIntTypeNonterminalParser->SetPost(PostUIntType);
6261 NonterminalParser* longTypeNonterminalParser = GetNonterminal(ToUtf32("LongType"));
6262 longTypeNonterminalParser->SetPre(PreLongType);
6263 longTypeNonterminalParser->SetPost(PostLongType);
6264 NonterminalParser* uLongTypeNonterminalParser = GetNonterminal(ToUtf32("ULongType"));
6265 uLongTypeNonterminalParser->SetPre(PreULongType);
6266 uLongTypeNonterminalParser->SetPost(PostULongType);
6267 NonterminalParser* floatTypeNonterminalParser = GetNonterminal(ToUtf32("FloatType"));
6268 floatTypeNonterminalParser->SetPre(PreFloatType);
6269 floatTypeNonterminalParser->SetPost(PostFloatType);
6270 NonterminalParser* doubleTypeNonterminalParser = GetNonterminal(ToUtf32("DoubleType"));
6271 doubleTypeNonterminalParser->SetPre(PreDoubleType);
6272 doubleTypeNonterminalParser->SetPost(PostDoubleType);
6273 }
6274 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
6275 {
6276 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6277 context->value = context->fromVoidType;
6278 }
6279 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
6280 {
6281 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6282 context->value = context->fromBoolType;
6283 }
6284 public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
6285 {
6286 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6287 context->value = context->fromSByteType;
6288 }
6289 public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
6290 {
6291 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6292 context->value = context->fromByteType;
6293 }
6294 public void A4Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
6295 {
6296 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6297 context->value = context->fromShortType;
6298 }
6299 public void A5Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
6300 {
6301 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6302 context->value = context->fromUShortType;
6303 }
6304 public void A6Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
6305 {
6306 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6307 context->value = context->fromIntType;
6308 }
6309 public void A7Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
6310 {
6311 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6312 context->value = context->fromUIntType;
6313 }
6314 public void A8Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
6315 {
6316 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6317 context->value = context->fromLongType;
6318 }
6319 public void A9Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
6320 {
6321 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6322 context->value = context->fromULongType;
6323 }
6324 public void A10Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
6325 {
6326 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6327 context->value = context->fromFloatType;
6328 }
6329 public void A11Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
6330 {
6331 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6332 context->value = context->fromDoubleType;
6333 }
6334 public void PreVoidType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
6335 {
6336 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6337 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
6338 }
6339 public void PostVoidType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6340 {
6341 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6342 if (matched)
6343 {
6344 UniquePtr<Object> fromVoidType_value = stack.Pop();
6345 context->fromVoidType = *cast<ValueObject<Type*>*>(fromVoidType_value.Get());
6346 }
6347 }
6348 public void PreBoolType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
6349 {
6350 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6351 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
6352 }
6353 public void PostBoolType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6354 {
6355 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6356 if (matched)
6357 {
6358 UniquePtr<Object> fromBoolType_value = stack.Pop();
6359 context->fromBoolType = *cast<ValueObject<Type*>*>(fromBoolType_value.Get());
6360 }
6361 }
6362 public void PreSByteType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
6363 {
6364 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6365 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
6366 }
6367 public void PostSByteType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6368 {
6369 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6370 if (matched)
6371 {
6372 UniquePtr<Object> fromSByteType_value = stack.Pop();
6373 context->fromSByteType = *cast<ValueObject<Type*>*>(fromSByteType_value.Get());
6374 }
6375 }
6376 public void PreByteType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
6377 {
6378 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6379 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
6380 }
6381 public void PostByteType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6382 {
6383 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6384 if (matched)
6385 {
6386 UniquePtr<Object> fromByteType_value = stack.Pop();
6387 context->fromByteType = *cast<ValueObject<Type*>*>(fromByteType_value.Get());
6388 }
6389 }
6390 public void PreShortType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
6391 {
6392 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6393 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
6394 }
6395 public void PostShortType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6396 {
6397 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6398 if (matched)
6399 {
6400 UniquePtr<Object> fromShortType_value = stack.Pop();
6401 context->fromShortType = *cast<ValueObject<Type*>*>(fromShortType_value.Get());
6402 }
6403 }
6404 public void PreUShortType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
6405 {
6406 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6407 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
6408 }
6409 public void PostUShortType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6410 {
6411 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6412 if (matched)
6413 {
6414 UniquePtr<Object> fromUShortType_value = stack.Pop();
6415 context->fromUShortType = *cast<ValueObject<Type*>*>(fromUShortType_value.Get());
6416 }
6417 }
6418 public void PreIntType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
6419 {
6420 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6421 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
6422 }
6423 public void PostIntType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6424 {
6425 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6426 if (matched)
6427 {
6428 UniquePtr<Object> fromIntType_value = stack.Pop();
6429 context->fromIntType = *cast<ValueObject<Type*>*>(fromIntType_value.Get());
6430 }
6431 }
6432 public void PreUIntType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
6433 {
6434 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6435 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
6436 }
6437 public void PostUIntType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6438 {
6439 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6440 if (matched)
6441 {
6442 UniquePtr<Object> fromUIntType_value = stack.Pop();
6443 context->fromUIntType = *cast<ValueObject<Type*>*>(fromUIntType_value.Get());
6444 }
6445 }
6446 public void PreLongType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
6447 {
6448 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6449 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
6450 }
6451 public void PostLongType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6452 {
6453 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6454 if (matched)
6455 {
6456 UniquePtr<Object> fromLongType_value = stack.Pop();
6457 context->fromLongType = *cast<ValueObject<Type*>*>(fromLongType_value.Get());
6458 }
6459 }
6460 public void PreULongType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
6461 {
6462 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6463 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
6464 }
6465 public void PostULongType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6466 {
6467 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6468 if (matched)
6469 {
6470 UniquePtr<Object> fromULongType_value = stack.Pop();
6471 context->fromULongType = *cast<ValueObject<Type*>*>(fromULongType_value.Get());
6472 }
6473 }
6474 public void PreFloatType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
6475 {
6476 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6477 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
6478 }
6479 public void PostFloatType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6480 {
6481 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6482 if (matched)
6483 {
6484 UniquePtr<Object> fromFloatType_value = stack.Pop();
6485 context->fromFloatType = *cast<ValueObject<Type*>*>(fromFloatType_value.Get());
6486 }
6487 }
6488 public void PreDoubleType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
6489 {
6490 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6491 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
6492 }
6493 public void PostDoubleType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6494 {
6495 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6496 if (matched)
6497 {
6498 UniquePtr<Object> fromDoubleType_value = stack.Pop();
6499 context->fromDoubleType = *cast<ValueObject<Type*>*>(fromDoubleType_value.Get());
6500 }
6501 }
6502 public class Context : System.Text.Parsing.Context
6503 {
6504 public Context() : context(), value(), fromVoidType(), fromBoolType(), fromSByteType(), fromByteType(), fromShortType(), fromUShortType(), fromIntType(), fromUIntType(), fromLongType(), fromULongType(), fromFloatType(), fromDoubleType()
6505 {
6506 }
6507 public cmsx.intermediate.Context* context;
6508 public Type* value;
6509 public Type* fromVoidType;
6510 public Type* fromBoolType;
6511 public Type* fromSByteType;
6512 public Type* fromByteType;
6513 public Type* fromShortType;
6514 public Type* fromUShortType;
6515 public Type* fromIntType;
6516 public Type* fromUIntType;
6517 public Type* fromLongType;
6518 public Type* fromULongType;
6519 public Type* fromFloatType;
6520 public Type* fromDoubleType;
6521 }
6522 }
6523
6524 public class VoidTypeRule : System.Text.Parsing.RuleParser
6525 {
6526 public VoidTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
6527 {
6528 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
6529 SetValueTypeName(ToUtf32("Type*"));
6530 }
6531 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
6532 {
6533 parsingData->PushContext(Id(), new Context());
6534 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6535 UniquePtr<Object> context_value = stack.Pop();
6536 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
6537 }
6538 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6539 {
6540 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6541 if (matched)
6542 {
6543 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
6544 }
6545 parsingData->PopContext(Id());
6546 }
6547 public override void Link()
6548 {
6549 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
6550 a0ActionParser->SetAction(A0Action);
6551 }
6552 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
6553 {
6554 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6555 context->value = context->context->GetVoidType();
6556 }
6557 public class Context : System.Text.Parsing.Context
6558 {
6559 public Context() : context(), value()
6560 {
6561 }
6562 public cmsx.intermediate.Context* context;
6563 public Type* value;
6564 }
6565 }
6566
6567 public class BoolTypeRule : System.Text.Parsing.RuleParser
6568 {
6569 public BoolTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
6570 {
6571 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
6572 SetValueTypeName(ToUtf32("Type*"));
6573 }
6574 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
6575 {
6576 parsingData->PushContext(Id(), new Context());
6577 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6578 UniquePtr<Object> context_value = stack.Pop();
6579 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
6580 }
6581 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6582 {
6583 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6584 if (matched)
6585 {
6586 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
6587 }
6588 parsingData->PopContext(Id());
6589 }
6590 public override void Link()
6591 {
6592 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
6593 a0ActionParser->SetAction(A0Action);
6594 }
6595 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
6596 {
6597 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6598 context->value = context->context->GetBoolType();
6599 }
6600 public class Context : System.Text.Parsing.Context
6601 {
6602 public Context() : context(), value()
6603 {
6604 }
6605 public cmsx.intermediate.Context* context;
6606 public Type* value;
6607 }
6608 }
6609
6610 public class SByteTypeRule : System.Text.Parsing.RuleParser
6611 {
6612 public SByteTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
6613 {
6614 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
6615 SetValueTypeName(ToUtf32("Type*"));
6616 }
6617 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
6618 {
6619 parsingData->PushContext(Id(), new Context());
6620 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6621 UniquePtr<Object> context_value = stack.Pop();
6622 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
6623 }
6624 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6625 {
6626 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6627 if (matched)
6628 {
6629 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
6630 }
6631 parsingData->PopContext(Id());
6632 }
6633 public override void Link()
6634 {
6635 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
6636 a0ActionParser->SetAction(A0Action);
6637 }
6638 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
6639 {
6640 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6641 context->value = context->context->GetSByteType();
6642 }
6643 public class Context : System.Text.Parsing.Context
6644 {
6645 public Context() : context(), value()
6646 {
6647 }
6648 public cmsx.intermediate.Context* context;
6649 public Type* value;
6650 }
6651 }
6652
6653 public class ByteTypeRule : System.Text.Parsing.RuleParser
6654 {
6655 public ByteTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
6656 {
6657 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
6658 SetValueTypeName(ToUtf32("Type*"));
6659 }
6660 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
6661 {
6662 parsingData->PushContext(Id(), new Context());
6663 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6664 UniquePtr<Object> context_value = stack.Pop();
6665 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
6666 }
6667 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6668 {
6669 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6670 if (matched)
6671 {
6672 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
6673 }
6674 parsingData->PopContext(Id());
6675 }
6676 public override void Link()
6677 {
6678 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
6679 a0ActionParser->SetAction(A0Action);
6680 }
6681 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
6682 {
6683 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6684 context->value = context->context->GetByteType();
6685 }
6686 public class Context : System.Text.Parsing.Context
6687 {
6688 public Context() : context(), value()
6689 {
6690 }
6691 public cmsx.intermediate.Context* context;
6692 public Type* value;
6693 }
6694 }
6695
6696 public class ShortTypeRule : System.Text.Parsing.RuleParser
6697 {
6698 public ShortTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
6699 {
6700 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
6701 SetValueTypeName(ToUtf32("Type*"));
6702 }
6703 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
6704 {
6705 parsingData->PushContext(Id(), new Context());
6706 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6707 UniquePtr<Object> context_value = stack.Pop();
6708 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
6709 }
6710 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6711 {
6712 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6713 if (matched)
6714 {
6715 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
6716 }
6717 parsingData->PopContext(Id());
6718 }
6719 public override void Link()
6720 {
6721 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
6722 a0ActionParser->SetAction(A0Action);
6723 }
6724 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
6725 {
6726 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6727 context->value = context->context->GetShortType();
6728 }
6729 public class Context : System.Text.Parsing.Context
6730 {
6731 public Context() : context(), value()
6732 {
6733 }
6734 public cmsx.intermediate.Context* context;
6735 public Type* value;
6736 }
6737 }
6738
6739 public class UShortTypeRule : System.Text.Parsing.RuleParser
6740 {
6741 public UShortTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
6742 {
6743 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
6744 SetValueTypeName(ToUtf32("Type*"));
6745 }
6746 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
6747 {
6748 parsingData->PushContext(Id(), new Context());
6749 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6750 UniquePtr<Object> context_value = stack.Pop();
6751 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
6752 }
6753 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6754 {
6755 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6756 if (matched)
6757 {
6758 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
6759 }
6760 parsingData->PopContext(Id());
6761 }
6762 public override void Link()
6763 {
6764 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
6765 a0ActionParser->SetAction(A0Action);
6766 }
6767 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
6768 {
6769 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6770 context->value = context->context->GetUShortType();
6771 }
6772 public class Context : System.Text.Parsing.Context
6773 {
6774 public Context() : context(), value()
6775 {
6776 }
6777 public cmsx.intermediate.Context* context;
6778 public Type* value;
6779 }
6780 }
6781
6782 public class IntTypeRule : System.Text.Parsing.RuleParser
6783 {
6784 public IntTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
6785 {
6786 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
6787 SetValueTypeName(ToUtf32("Type*"));
6788 }
6789 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
6790 {
6791 parsingData->PushContext(Id(), new Context());
6792 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6793 UniquePtr<Object> context_value = stack.Pop();
6794 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
6795 }
6796 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6797 {
6798 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6799 if (matched)
6800 {
6801 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
6802 }
6803 parsingData->PopContext(Id());
6804 }
6805 public override void Link()
6806 {
6807 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
6808 a0ActionParser->SetAction(A0Action);
6809 }
6810 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
6811 {
6812 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6813 context->value = context->context->GetIntType();
6814 }
6815 public class Context : System.Text.Parsing.Context
6816 {
6817 public Context() : context(), value()
6818 {
6819 }
6820 public cmsx.intermediate.Context* context;
6821 public Type* value;
6822 }
6823 }
6824
6825 public class UIntTypeRule : System.Text.Parsing.RuleParser
6826 {
6827 public UIntTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
6828 {
6829 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
6830 SetValueTypeName(ToUtf32("Type*"));
6831 }
6832 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
6833 {
6834 parsingData->PushContext(Id(), new Context());
6835 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6836 UniquePtr<Object> context_value = stack.Pop();
6837 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
6838 }
6839 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6840 {
6841 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6842 if (matched)
6843 {
6844 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
6845 }
6846 parsingData->PopContext(Id());
6847 }
6848 public override void Link()
6849 {
6850 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
6851 a0ActionParser->SetAction(A0Action);
6852 }
6853 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
6854 {
6855 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6856 context->value = context->context->GetUIntType();
6857 }
6858 public class Context : System.Text.Parsing.Context
6859 {
6860 public Context() : context(), value()
6861 {
6862 }
6863 public cmsx.intermediate.Context* context;
6864 public Type* value;
6865 }
6866 }
6867
6868 public class LongTypeRule : System.Text.Parsing.RuleParser
6869 {
6870 public LongTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
6871 {
6872 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
6873 SetValueTypeName(ToUtf32("Type*"));
6874 }
6875 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
6876 {
6877 parsingData->PushContext(Id(), new Context());
6878 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6879 UniquePtr<Object> context_value = stack.Pop();
6880 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
6881 }
6882 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6883 {
6884 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6885 if (matched)
6886 {
6887 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
6888 }
6889 parsingData->PopContext(Id());
6890 }
6891 public override void Link()
6892 {
6893 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
6894 a0ActionParser->SetAction(A0Action);
6895 }
6896 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
6897 {
6898 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6899 context->value = context->context->GetLongType();
6900 }
6901 public class Context : System.Text.Parsing.Context
6902 {
6903 public Context() : context(), value()
6904 {
6905 }
6906 public cmsx.intermediate.Context* context;
6907 public Type* value;
6908 }
6909 }
6910
6911 public class ULongTypeRule : System.Text.Parsing.RuleParser
6912 {
6913 public ULongTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
6914 {
6915 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
6916 SetValueTypeName(ToUtf32("Type*"));
6917 }
6918 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
6919 {
6920 parsingData->PushContext(Id(), new Context());
6921 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6922 UniquePtr<Object> context_value = stack.Pop();
6923 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
6924 }
6925 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6926 {
6927 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6928 if (matched)
6929 {
6930 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
6931 }
6932 parsingData->PopContext(Id());
6933 }
6934 public override void Link()
6935 {
6936 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
6937 a0ActionParser->SetAction(A0Action);
6938 }
6939 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
6940 {
6941 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6942 context->value = context->context->GetULongType();
6943 }
6944 public class Context : System.Text.Parsing.Context
6945 {
6946 public Context() : context(), value()
6947 {
6948 }
6949 public cmsx.intermediate.Context* context;
6950 public Type* value;
6951 }
6952 }
6953
6954 public class FloatTypeRule : System.Text.Parsing.RuleParser
6955 {
6956 public FloatTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
6957 {
6958 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
6959 SetValueTypeName(ToUtf32("Type*"));
6960 }
6961 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
6962 {
6963 parsingData->PushContext(Id(), new Context());
6964 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6965 UniquePtr<Object> context_value = stack.Pop();
6966 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
6967 }
6968 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6969 {
6970 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6971 if (matched)
6972 {
6973 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
6974 }
6975 parsingData->PopContext(Id());
6976 }
6977 public override void Link()
6978 {
6979 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
6980 a0ActionParser->SetAction(A0Action);
6981 }
6982 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
6983 {
6984 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6985 context->value = context->context->GetFloatType();
6986 }
6987 public class Context : System.Text.Parsing.Context
6988 {
6989 public Context() : context(), value()
6990 {
6991 }
6992 public cmsx.intermediate.Context* context;
6993 public Type* value;
6994 }
6995 }
6996
6997 public class DoubleTypeRule : System.Text.Parsing.RuleParser
6998 {
6999 public DoubleTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
7000 {
7001 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
7002 SetValueTypeName(ToUtf32("Type*"));
7003 }
7004 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7005 {
7006 parsingData->PushContext(Id(), new Context());
7007 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7008 UniquePtr<Object> context_value = stack.Pop();
7009 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
7010 }
7011 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7012 {
7013 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7014 if (matched)
7015 {
7016 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
7017 }
7018 parsingData->PopContext(Id());
7019 }
7020 public override void Link()
7021 {
7022 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
7023 a0ActionParser->SetAction(A0Action);
7024 }
7025 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
7026 {
7027 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7028 context->value = context->context->GetDoubleType();
7029 }
7030 public class Context : System.Text.Parsing.Context
7031 {
7032 public Context() : context(), value()
7033 {
7034 }
7035 public cmsx.intermediate.Context* context;
7036 public Type* value;
7037 }
7038 }
7039
7040 public class DataDefinitionRule : System.Text.Parsing.RuleParser
7041 {
7042 public DataDefinitionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
7043 {
7044 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
7045 AddLocalVariable(AttrOrVar(ToUtf32("bool"), ToUtf32("once")));
7046 }
7047 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7048 {
7049 parsingData->PushContext(Id(), new Context());
7050 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7051 UniquePtr<Object> context_value = stack.Pop();
7052 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
7053 }
7054 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7055 {
7056 parsingData->PopContext(Id());
7057 }
7058 public override void Link()
7059 {
7060 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
7061 a0ActionParser->SetAction(A0Action);
7062 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
7063 a1ActionParser->SetAction(A1Action);
7064 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
7065 a2ActionParser->SetAction(A2Action);
7066 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
7067 typeNonterminalParser->SetPre(Pretype);
7068 typeNonterminalParser->SetPost(Posttype);
7069 NonterminalParser* nameNonterminalParser = GetNonterminal(ToUtf32("name"));
7070 nameNonterminalParser->SetPost(Postname);
7071 NonterminalParser* constantNonterminalParser = GetNonterminal(ToUtf32("Constant"));
7072 constantNonterminalParser->SetPre(PreConstant);
7073 constantNonterminalParser->SetPost(PostConstant);
7074 }
7075 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
7076 {
7077 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7078 context->once = true;
7079 }
7080 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
7081 {
7082 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7083 context->context->AddGlobalVariable(context->fromtype, ToUtf8(context->fromname), cast<ConstantValue*>(null), span.lineNumber, context->once);
7084 }
7085 public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
7086 {
7087 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7088 context->context->AddGlobalVariable(context->fromtype, ToUtf8(context->fromname), context->fromConstant, span.lineNumber, context->once);
7089 }
7090 public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7091 {
7092 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7093 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
7094 }
7095 public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7096 {
7097 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7098 if (matched)
7099 {
7100 UniquePtr<Object> fromtype_value = stack.Pop();
7101 context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
7102 }
7103 }
7104 public void Postname(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7105 {
7106 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7107 if (matched)
7108 {
7109 UniquePtr<Object> fromname_value = stack.Pop();
7110 context->fromname = *cast<ValueObject<ustring>*>(fromname_value.Get());
7111 }
7112 }
7113 public void PreConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7114 {
7115 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7116 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
7117 }
7118 public void PostConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7119 {
7120 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7121 if (matched)
7122 {
7123 UniquePtr<Object> fromConstant_value = stack.Pop();
7124 context->fromConstant = *cast<ValueObject<ConstantValue*>*>(fromConstant_value.Get());
7125 }
7126 }
7127 public class Context : System.Text.Parsing.Context
7128 {
7129 public Context() : context(), once(), fromtype(), fromname(), fromConstant()
7130 {
7131 }
7132 public cmsx.intermediate.Context* context;
7133 public bool once;
7134 public Type* fromtype;
7135 public ustring fromname;
7136 public ConstantValue* fromConstant;
7137 }
7138 }
7139
7140 public class ConstantRule : System.Text.Parsing.RuleParser
7141 {
7142 public ConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
7143 {
7144 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
7145 SetValueTypeName(ToUtf32("ConstantValue*"));
7146 }
7147 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7148 {
7149 parsingData->PushContext(Id(), new Context());
7150 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7151 UniquePtr<Object> context_value = stack.Pop();
7152 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
7153 }
7154 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7155 {
7156 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7157 if (matched)
7158 {
7159 stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
7160 }
7161 parsingData->PopContext(Id());
7162 }
7163 public override void Link()
7164 {
7165 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
7166 a0ActionParser->SetAction(A0Action);
7167 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
7168 a1ActionParser->SetAction(A1Action);
7169 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
7170 a2ActionParser->SetAction(A2Action);
7171 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
7172 a3ActionParser->SetAction(A3Action);
7173 ActionParser* a4ActionParser = GetAction(ToUtf32("A4"));
7174 a4ActionParser->SetAction(A4Action);
7175 ActionParser* a5ActionParser = GetAction(ToUtf32("A5"));
7176 a5ActionParser->SetAction(A5Action);
7177 ActionParser* a6ActionParser = GetAction(ToUtf32("A6"));
7178 a6ActionParser->SetAction(A6Action);
7179 ActionParser* a7ActionParser = GetAction(ToUtf32("A7"));
7180 a7ActionParser->SetAction(A7Action);
7181 ActionParser* a8ActionParser = GetAction(ToUtf32("A8"));
7182 a8ActionParser->SetAction(A8Action);
7183 ActionParser* a9ActionParser = GetAction(ToUtf32("A9"));
7184 a9ActionParser->SetAction(A9Action);
7185 ActionParser* a10ActionParser = GetAction(ToUtf32("A10"));
7186 a10ActionParser->SetAction(A10Action);
7187 ActionParser* a11ActionParser = GetAction(ToUtf32("A11"));
7188 a11ActionParser->SetAction(A11Action);
7189 ActionParser* a12ActionParser = GetAction(ToUtf32("A12"));
7190 a12ActionParser->SetAction(A12Action);
7191 ActionParser* a13ActionParser = GetAction(ToUtf32("A13"));
7192 a13ActionParser->SetAction(A13Action);
7193 ActionParser* a14ActionParser = GetAction(ToUtf32("A14"));
7194 a14ActionParser->SetAction(A14Action);
7195 ActionParser* a15ActionParser = GetAction(ToUtf32("A15"));
7196 a15ActionParser->SetAction(A15Action);
7197 ActionParser* a16ActionParser = GetAction(ToUtf32("A16"));
7198 a16ActionParser->SetAction(A16Action);
7199 ActionParser* a17ActionParser = GetAction(ToUtf32("A17"));
7200 a17ActionParser->SetAction(A17Action);
7201 ActionParser* a18ActionParser = GetAction(ToUtf32("A18"));
7202 a18ActionParser->SetAction(A18Action);
7203 NonterminalParser* conversionConstantNonterminalParser = GetNonterminal(ToUtf32("ConversionConstant"));
7204 conversionConstantNonterminalParser->SetPre(PreConversionConstant);
7205 conversionConstantNonterminalParser->SetPost(PostConversionConstant);
7206 NonterminalParser* clsIdConstantNonterminalParser = GetNonterminal(ToUtf32("ClsIdConstant"));
7207 clsIdConstantNonterminalParser->SetPre(PreClsIdConstant);
7208 clsIdConstantNonterminalParser->SetPost(PostClsIdConstant);
7209 NonterminalParser* ptrConstantNonterminalParser = GetNonterminal(ToUtf32("PtrConstant"));
7210 ptrConstantNonterminalParser->SetPre(PrePtrConstant);
7211 ptrConstantNonterminalParser->SetPost(PostPtrConstant);
7212 NonterminalParser* symbolConstantNonterminalParser = GetNonterminal(ToUtf32("SymbolConstant"));
7213 symbolConstantNonterminalParser->SetPre(PreSymbolConstant);
7214 symbolConstantNonterminalParser->SetPost(PostSymbolConstant);
7215 NonterminalParser* boolConstantNonterminalParser = GetNonterminal(ToUtf32("BoolConstant"));
7216 boolConstantNonterminalParser->SetPre(PreBoolConstant);
7217 boolConstantNonterminalParser->SetPost(PostBoolConstant);
7218 NonterminalParser* sByteConstantNonterminalParser = GetNonterminal(ToUtf32("SByteConstant"));
7219 sByteConstantNonterminalParser->SetPre(PreSByteConstant);
7220 sByteConstantNonterminalParser->SetPost(PostSByteConstant);
7221 NonterminalParser* byteConstantNonterminalParser = GetNonterminal(ToUtf32("ByteConstant"));
7222 byteConstantNonterminalParser->SetPre(PreByteConstant);
7223 byteConstantNonterminalParser->SetPost(PostByteConstant);
7224 NonterminalParser* shortConstantNonterminalParser = GetNonterminal(ToUtf32("ShortConstant"));
7225 shortConstantNonterminalParser->SetPre(PreShortConstant);
7226 shortConstantNonterminalParser->SetPost(PostShortConstant);
7227 NonterminalParser* uShortConstantNonterminalParser = GetNonterminal(ToUtf32("UShortConstant"));
7228 uShortConstantNonterminalParser->SetPre(PreUShortConstant);
7229 uShortConstantNonterminalParser->SetPost(PostUShortConstant);
7230 NonterminalParser* intConstantNonterminalParser = GetNonterminal(ToUtf32("IntConstant"));
7231 intConstantNonterminalParser->SetPre(PreIntConstant);
7232 intConstantNonterminalParser->SetPost(PostIntConstant);
7233 NonterminalParser* uIntConstantNonterminalParser = GetNonterminal(ToUtf32("UIntConstant"));
7234 uIntConstantNonterminalParser->SetPre(PreUIntConstant);
7235 uIntConstantNonterminalParser->SetPost(PostUIntConstant);
7236 NonterminalParser* longConstantNonterminalParser = GetNonterminal(ToUtf32("LongConstant"));
7237 longConstantNonterminalParser->SetPre(PreLongConstant);
7238 longConstantNonterminalParser->SetPost(PostLongConstant);
7239 NonterminalParser* uLongConstantNonterminalParser = GetNonterminal(ToUtf32("ULongConstant"));
7240 uLongConstantNonterminalParser->SetPre(PreULongConstant);
7241 uLongConstantNonterminalParser->SetPost(PostULongConstant);
7242 NonterminalParser* floatConstantNonterminalParser = GetNonterminal(ToUtf32("FloatConstant"));
7243 floatConstantNonterminalParser->SetPre(PreFloatConstant);
7244 floatConstantNonterminalParser->SetPost(PostFloatConstant);
7245 NonterminalParser* doubleConstantNonterminalParser = GetNonterminal(ToUtf32("DoubleConstant"));
7246 doubleConstantNonterminalParser->SetPre(PreDoubleConstant);
7247 doubleConstantNonterminalParser->SetPost(PostDoubleConstant);
7248 NonterminalParser* arrayConstantNonterminalParser = GetNonterminal(ToUtf32("ArrayConstant"));
7249 arrayConstantNonterminalParser->SetPre(PreArrayConstant);
7250 arrayConstantNonterminalParser->SetPost(PostArrayConstant);
7251 NonterminalParser* structureConstantNonterminalParser = GetNonterminal(ToUtf32("StructureConstant"));
7252 structureConstantNonterminalParser->SetPre(PreStructureConstant);
7253 structureConstantNonterminalParser->SetPost(PostStructureConstant);
7254 NonterminalParser* stringConstantNonterminalParser = GetNonterminal(ToUtf32("StringConstant"));
7255 stringConstantNonterminalParser->SetPre(PreStringConstant);
7256 stringConstantNonterminalParser->SetPost(PostStringConstant);
7257 NonterminalParser* stringArrayConstantNonterminalParser = GetNonterminal(ToUtf32("StringArrayConstant"));
7258 stringArrayConstantNonterminalParser->SetPre(PreStringArrayConstant);
7259 stringArrayConstantNonterminalParser->SetPost(PostStringArrayConstant);
7260 }
7261 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
7262 {
7263 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7264 context->value = context->fromConversionConstant;
7265 }
7266 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
7267 {
7268 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7269 context->value = context->fromClsIdConstant;
7270 }
7271 public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
7272 {
7273 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7274 context->value = context->fromPtrConstant;
7275 }
7276 public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
7277 {
7278 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7279 context->value = context->fromSymbolConstant;
7280 }
7281 public void A4Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
7282 {
7283 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7284 context->value = context->fromBoolConstant;
7285 }
7286 public void A5Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
7287 {
7288 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7289 context->value = context->fromSByteConstant;
7290 }
7291 public void A6Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
7292 {
7293 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7294 context->value = context->fromByteConstant;
7295 }
7296 public void A7Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
7297 {
7298 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7299 context->value = context->fromShortConstant;
7300 }
7301 public void A8Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
7302 {
7303 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7304 context->value = context->fromUShortConstant;
7305 }
7306 public void A9Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
7307 {
7308 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7309 context->value = context->fromIntConstant;
7310 }
7311 public void A10Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
7312 {
7313 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7314 context->value = context->fromUIntConstant;
7315 }
7316 public void A11Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
7317 {
7318 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7319 context->value = context->fromLongConstant;
7320 }
7321 public void A12Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
7322 {
7323 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7324 context->value = context->fromULongConstant;
7325 }
7326 public void A13Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
7327 {
7328 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7329 context->value = context->fromFloatConstant;
7330 }
7331 public void A14Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
7332 {
7333 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7334 context->value = context->fromDoubleConstant;
7335 }
7336 public void A15Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
7337 {
7338 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7339 context->value = context->fromArrayConstant;
7340 }
7341 public void A16Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
7342 {
7343 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7344 context->value = context->fromStructureConstant;
7345 }
7346 public void A17Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
7347 {
7348 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7349 context->value = context->fromStringConstant;
7350 }
7351 public void A18Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
7352 {
7353 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7354 context->value = context->fromStringArrayConstant;
7355 }
7356 public void PreConversionConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7357 {
7358 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7359 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
7360 }
7361 public void PostConversionConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7362 {
7363 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7364 if (matched)
7365 {
7366 UniquePtr<Object> fromConversionConstant_value = stack.Pop();
7367 context->fromConversionConstant = *cast<ValueObject<ConstantValue*>*>(fromConversionConstant_value.Get());
7368 }
7369 }
7370 public void PreClsIdConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7371 {
7372 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7373 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
7374 }
7375 public void PostClsIdConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7376 {
7377 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7378 if (matched)
7379 {
7380 UniquePtr<Object> fromClsIdConstant_value = stack.Pop();
7381 context->fromClsIdConstant = *cast<ValueObject<ConstantValue*>*>(fromClsIdConstant_value.Get());
7382 }
7383 }
7384 public void PrePtrConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7385 {
7386 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7387 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
7388 }
7389 public void PostPtrConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7390 {
7391 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7392 if (matched)
7393 {
7394 UniquePtr<Object> fromPtrConstant_value = stack.Pop();
7395 context->fromPtrConstant = *cast<ValueObject<ConstantValue*>*>(fromPtrConstant_value.Get());
7396 }
7397 }
7398 public void PreSymbolConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7399 {
7400 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7401 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
7402 }
7403 public void PostSymbolConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7404 {
7405 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7406 if (matched)
7407 {
7408 UniquePtr<Object> fromSymbolConstant_value = stack.Pop();
7409 context->fromSymbolConstant = *cast<ValueObject<ConstantValue*>*>(fromSymbolConstant_value.Get());
7410 }
7411 }
7412 public void PreBoolConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7413 {
7414 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7415 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
7416 }
7417 public void PostBoolConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7418 {
7419 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7420 if (matched)
7421 {
7422 UniquePtr<Object> fromBoolConstant_value = stack.Pop();
7423 context->fromBoolConstant = *cast<ValueObject<ConstantValue*>*>(fromBoolConstant_value.Get());
7424 }
7425 }
7426 public void PreSByteConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7427 {
7428 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7429 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
7430 }
7431 public void PostSByteConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7432 {
7433 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7434 if (matched)
7435 {
7436 UniquePtr<Object> fromSByteConstant_value = stack.Pop();
7437 context->fromSByteConstant = *cast<ValueObject<ConstantValue*>*>(fromSByteConstant_value.Get());
7438 }
7439 }
7440 public void PreByteConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7441 {
7442 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7443 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
7444 }
7445 public void PostByteConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7446 {
7447 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7448 if (matched)
7449 {
7450 UniquePtr<Object> fromByteConstant_value = stack.Pop();
7451 context->fromByteConstant = *cast<ValueObject<ConstantValue*>*>(fromByteConstant_value.Get());
7452 }
7453 }
7454 public void PreShortConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7455 {
7456 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7457 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
7458 }
7459 public void PostShortConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7460 {
7461 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7462 if (matched)
7463 {
7464 UniquePtr<Object> fromShortConstant_value = stack.Pop();
7465 context->fromShortConstant = *cast<ValueObject<ConstantValue*>*>(fromShortConstant_value.Get());
7466 }
7467 }
7468 public void PreUShortConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7469 {
7470 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7471 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
7472 }
7473 public void PostUShortConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7474 {
7475 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7476 if (matched)
7477 {
7478 UniquePtr<Object> fromUShortConstant_value = stack.Pop();
7479 context->fromUShortConstant = *cast<ValueObject<ConstantValue*>*>(fromUShortConstant_value.Get());
7480 }
7481 }
7482 public void PreIntConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7483 {
7484 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7485 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
7486 }
7487 public void PostIntConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7488 {
7489 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7490 if (matched)
7491 {
7492 UniquePtr<Object> fromIntConstant_value = stack.Pop();
7493 context->fromIntConstant = *cast<ValueObject<ConstantValue*>*>(fromIntConstant_value.Get());
7494 }
7495 }
7496 public void PreUIntConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7497 {
7498 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7499 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
7500 }
7501 public void PostUIntConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7502 {
7503 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7504 if (matched)
7505 {
7506 UniquePtr<Object> fromUIntConstant_value = stack.Pop();
7507 context->fromUIntConstant = *cast<ValueObject<ConstantValue*>*>(fromUIntConstant_value.Get());
7508 }
7509 }
7510 public void PreLongConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7511 {
7512 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7513 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
7514 }
7515 public void PostLongConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7516 {
7517 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7518 if (matched)
7519 {
7520 UniquePtr<Object> fromLongConstant_value = stack.Pop();
7521 context->fromLongConstant = *cast<ValueObject<ConstantValue*>*>(fromLongConstant_value.Get());
7522 }
7523 }
7524 public void PreULongConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7525 {
7526 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7527 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
7528 }
7529 public void PostULongConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7530 {
7531 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7532 if (matched)
7533 {
7534 UniquePtr<Object> fromULongConstant_value = stack.Pop();
7535 context->fromULongConstant = *cast<ValueObject<ConstantValue*>*>(fromULongConstant_value.Get());
7536 }
7537 }
7538 public void PreFloatConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7539 {
7540 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7541 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
7542 }
7543 public void PostFloatConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7544 {
7545 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7546 if (matched)
7547 {
7548 UniquePtr<Object> fromFloatConstant_value = stack.Pop();
7549 context->fromFloatConstant = *cast<ValueObject<ConstantValue*>*>(fromFloatConstant_value.Get());
7550 }
7551 }
7552 public void PreDoubleConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7553 {
7554 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7555 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
7556 }
7557 public void PostDoubleConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7558 {
7559 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7560 if (matched)
7561 {
7562 UniquePtr<Object> fromDoubleConstant_value = stack.Pop();
7563 context->fromDoubleConstant = *cast<ValueObject<ConstantValue*>*>(fromDoubleConstant_value.Get());
7564 }
7565 }
7566 public void PreArrayConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7567 {
7568 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7569 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
7570 }
7571 public void PostArrayConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7572 {
7573 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7574 if (matched)
7575 {
7576 UniquePtr<Object> fromArrayConstant_value = stack.Pop();
7577 context->fromArrayConstant = *cast<ValueObject<ArrayValue*>*>(fromArrayConstant_value.Get());
7578 }
7579 }
7580 public void PreStructureConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7581 {
7582 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7583 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
7584 }
7585 public void PostStructureConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7586 {
7587 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7588 if (matched)
7589 {
7590 UniquePtr<Object> fromStructureConstant_value = stack.Pop();
7591 context->fromStructureConstant = *cast<ValueObject<StructureValue*>*>(fromStructureConstant_value.Get());
7592 }
7593 }
7594 public void PreStringConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7595 {
7596 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7597 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
7598 }
7599 public void PostStringConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7600 {
7601 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7602 if (matched)
7603 {
7604 UniquePtr<Object> fromStringConstant_value = stack.Pop();
7605 context->fromStringConstant = *cast<ValueObject<StringValue*>*>(fromStringConstant_value.Get());
7606 }
7607 }
7608 public void PreStringArrayConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7609 {
7610 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7611 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
7612 }
7613 public void PostStringArrayConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7614 {
7615 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7616 if (matched)
7617 {
7618 UniquePtr<Object> fromStringArrayConstant_value = stack.Pop();
7619 context->fromStringArrayConstant = *cast<ValueObject<StringArrayValue*>*>(fromStringArrayConstant_value.Get());
7620 }
7621 }
7622 public class Context : System.Text.Parsing.Context
7623 {
7624 public Context() : context(), value(), fromConversionConstant(), fromClsIdConstant(), fromPtrConstant(), fromSymbolConstant(), fromBoolConstant(), fromSByteConstant(), fromByteConstant(), fromShortConstant(), fromUShortConstant(), fromIntConstant(), fromUIntConstant(), fromLongConstant(), fromULongConstant(), fromFloatConstant(), fromDoubleConstant(), fromArrayConstant(), fromStructureConstant(), fromStringConstant(), fromStringArrayConstant()
7625 {
7626 }
7627 public cmsx.intermediate.Context* context;
7628 public ConstantValue* value;
7629 public ConstantValue* fromConversionConstant;
7630 public ConstantValue* fromClsIdConstant;
7631 public ConstantValue* fromPtrConstant;
7632 public ConstantValue* fromSymbolConstant;
7633 public ConstantValue* fromBoolConstant;
7634 public ConstantValue* fromSByteConstant;
7635 public ConstantValue* fromByteConstant;
7636 public ConstantValue* fromShortConstant;
7637 public ConstantValue* fromUShortConstant;
7638 public ConstantValue* fromIntConstant;
7639 public ConstantValue* fromUIntConstant;
7640 public ConstantValue* fromLongConstant;
7641 public ConstantValue* fromULongConstant;
7642 public ConstantValue* fromFloatConstant;
7643 public ConstantValue* fromDoubleConstant;
7644 public ArrayValue* fromArrayConstant;
7645 public StructureValue* fromStructureConstant;
7646 public StringValue* fromStringConstant;
7647 public StringArrayValue* fromStringArrayConstant;
7648 }
7649 }
7650
7651 public class BoolConstantRule : System.Text.Parsing.RuleParser
7652 {
7653 public BoolConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
7654 {
7655 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
7656 SetValueTypeName(ToUtf32("ConstantValue*"));
7657 }
7658 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7659 {
7660 parsingData->PushContext(Id(), new Context());
7661 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7662 UniquePtr<Object> context_value = stack.Pop();
7663 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
7664 }
7665 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7666 {
7667 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7668 if (matched)
7669 {
7670 stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
7671 }
7672 parsingData->PopContext(Id());
7673 }
7674 public override void Link()
7675 {
7676 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
7677 a0ActionParser->SetAction(A0Action);
7678 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
7679 typeNonterminalParser->SetPre(Pretype);
7680 typeNonterminalParser->SetPost(Posttype);
7681 NonterminalParser* valNonterminalParser = GetNonterminal(ToUtf32("val"));
7682 valNonterminalParser->SetPost(Postval);
7683 }
7684 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
7685 {
7686 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7687 context->value = cast<BoolType*>(context->fromtype)->MakeBoolValue(context->fromval);
7688 }
7689 public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7690 {
7691 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7692 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
7693 }
7694 public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7695 {
7696 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7697 if (matched)
7698 {
7699 UniquePtr<Object> fromtype_value = stack.Pop();
7700 context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
7701 }
7702 }
7703 public void Postval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7704 {
7705 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7706 if (matched)
7707 {
7708 UniquePtr<Object> fromval_value = stack.Pop();
7709 context->fromval = *cast<ValueObject<bool>*>(fromval_value.Get());
7710 }
7711 }
7712 public class Context : System.Text.Parsing.Context
7713 {
7714 public Context() : context(), value(), fromtype(), fromval()
7715 {
7716 }
7717 public cmsx.intermediate.Context* context;
7718 public ConstantValue* value;
7719 public Type* fromtype;
7720 public bool fromval;
7721 }
7722 }
7723
7724 public class BoolValueRule : System.Text.Parsing.RuleParser
7725 {
7726 public BoolValueRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
7727 {
7728 SetValueTypeName(ToUtf32("bool"));
7729 }
7730 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7731 {
7732 parsingData->PushContext(Id(), new Context());
7733 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7734 }
7735 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7736 {
7737 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7738 if (matched)
7739 {
7740 stack.Push(UniquePtr<Object>(new ValueObject<bool>(context->value)));
7741 }
7742 parsingData->PopContext(Id());
7743 }
7744 public override void Link()
7745 {
7746 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
7747 a0ActionParser->SetAction(A0Action);
7748 NonterminalParser* xNonterminalParser = GetNonterminal(ToUtf32("x"));
7749 xNonterminalParser->SetPost(Postx);
7750 }
7751 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
7752 {
7753 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7754 context->value = context->fromx;
7755 }
7756 public void Postx(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7757 {
7758 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7759 if (matched)
7760 {
7761 UniquePtr<Object> fromx_value = stack.Pop();
7762 context->fromx = *cast<ValueObject<bool>*>(fromx_value.Get());
7763 }
7764 }
7765 public class Context : System.Text.Parsing.Context
7766 {
7767 public Context() : value(), fromx()
7768 {
7769 }
7770 public bool value;
7771 public bool fromx;
7772 }
7773 }
7774
7775 public class SByteConstantRule : System.Text.Parsing.RuleParser
7776 {
7777 public SByteConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
7778 {
7779 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
7780 SetValueTypeName(ToUtf32("ConstantValue*"));
7781 }
7782 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7783 {
7784 parsingData->PushContext(Id(), new Context());
7785 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7786 UniquePtr<Object> context_value = stack.Pop();
7787 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
7788 }
7789 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7790 {
7791 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7792 if (matched)
7793 {
7794 stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
7795 }
7796 parsingData->PopContext(Id());
7797 }
7798 public override void Link()
7799 {
7800 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
7801 a0ActionParser->SetAction(A0Action);
7802 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
7803 typeNonterminalParser->SetPre(Pretype);
7804 typeNonterminalParser->SetPost(Posttype);
7805 NonterminalParser* valNonterminalParser = GetNonterminal(ToUtf32("val"));
7806 valNonterminalParser->SetPost(Postval);
7807 }
7808 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
7809 {
7810 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7811 context->value = context->context->MakeSByteValue(cast<SByteType*>(context->fromtype), context->fromval);
7812 }
7813 public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7814 {
7815 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7816 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
7817 }
7818 public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7819 {
7820 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7821 if (matched)
7822 {
7823 UniquePtr<Object> fromtype_value = stack.Pop();
7824 context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
7825 }
7826 }
7827 public void Postval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7828 {
7829 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7830 if (matched)
7831 {
7832 UniquePtr<Object> fromval_value = stack.Pop();
7833 context->fromval = *cast<ValueObject<sbyte>*>(fromval_value.Get());
7834 }
7835 }
7836 public class Context : System.Text.Parsing.Context
7837 {
7838 public Context() : context(), value(), fromtype(), fromval()
7839 {
7840 }
7841 public cmsx.intermediate.Context* context;
7842 public ConstantValue* value;
7843 public Type* fromtype;
7844 public sbyte fromval;
7845 }
7846 }
7847
7848 public class SByteValueRule : System.Text.Parsing.RuleParser
7849 {
7850 public SByteValueRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
7851 {
7852 SetValueTypeName(ToUtf32("sbyte"));
7853 }
7854 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7855 {
7856 parsingData->PushContext(Id(), new Context());
7857 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7858 }
7859 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7860 {
7861 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7862 if (matched)
7863 {
7864 stack.Push(UniquePtr<Object>(new ValueObject<sbyte>(context->value)));
7865 }
7866 parsingData->PopContext(Id());
7867 }
7868 public override void Link()
7869 {
7870 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
7871 a0ActionParser->SetAction(A0Action);
7872 NonterminalParser* xNonterminalParser = GetNonterminal(ToUtf32("x"));
7873 xNonterminalParser->SetPost(Postx);
7874 }
7875 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
7876 {
7877 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7878 context->value = context->fromx;
7879 }
7880 public void Postx(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7881 {
7882 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7883 if (matched)
7884 {
7885 UniquePtr<Object> fromx_value = stack.Pop();
7886 context->fromx = *cast<ValueObject<sbyte>*>(fromx_value.Get());
7887 }
7888 }
7889 public class Context : System.Text.Parsing.Context
7890 {
7891 public Context() : value(), fromx()
7892 {
7893 }
7894 public sbyte value;
7895 public sbyte fromx;
7896 }
7897 }
7898
7899 public class ByteConstantRule : System.Text.Parsing.RuleParser
7900 {
7901 public ByteConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
7902 {
7903 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
7904 SetValueTypeName(ToUtf32("ConstantValue*"));
7905 }
7906 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7907 {
7908 parsingData->PushContext(Id(), new Context());
7909 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7910 UniquePtr<Object> context_value = stack.Pop();
7911 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
7912 }
7913 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7914 {
7915 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7916 if (matched)
7917 {
7918 stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
7919 }
7920 parsingData->PopContext(Id());
7921 }
7922 public override void Link()
7923 {
7924 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
7925 a0ActionParser->SetAction(A0Action);
7926 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
7927 typeNonterminalParser->SetPre(Pretype);
7928 typeNonterminalParser->SetPost(Posttype);
7929 NonterminalParser* valNonterminalParser = GetNonterminal(ToUtf32("val"));
7930 valNonterminalParser->SetPost(Postval);
7931 }
7932 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
7933 {
7934 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7935 context->value = context->context->MakeByteValue(cast<ByteType*>(context->fromtype), context->fromval);
7936 }
7937 public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7938 {
7939 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7940 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
7941 }
7942 public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7943 {
7944 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7945 if (matched)
7946 {
7947 UniquePtr<Object> fromtype_value = stack.Pop();
7948 context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
7949 }
7950 }
7951 public void Postval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7952 {
7953 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7954 if (matched)
7955 {
7956 UniquePtr<Object> fromval_value = stack.Pop();
7957 context->fromval = *cast<ValueObject<byte>*>(fromval_value.Get());
7958 }
7959 }
7960 public class Context : System.Text.Parsing.Context
7961 {
7962 public Context() : context(), value(), fromtype(), fromval()
7963 {
7964 }
7965 public cmsx.intermediate.Context* context;
7966 public ConstantValue* value;
7967 public Type* fromtype;
7968 public byte fromval;
7969 }
7970 }
7971
7972 public class ByteValueRule : System.Text.Parsing.RuleParser
7973 {
7974 public ByteValueRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
7975 {
7976 SetValueTypeName(ToUtf32("byte"));
7977 }
7978 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7979 {
7980 parsingData->PushContext(Id(), new Context());
7981 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7982 }
7983 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7984 {
7985 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7986 if (matched)
7987 {
7988 stack.Push(UniquePtr<Object>(new ValueObject<byte>(context->value)));
7989 }
7990 parsingData->PopContext(Id());
7991 }
7992 public override void Link()
7993 {
7994 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
7995 a0ActionParser->SetAction(A0Action);
7996 NonterminalParser* xNonterminalParser = GetNonterminal(ToUtf32("x"));
7997 xNonterminalParser->SetPost(Postx);
7998 }
7999 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
8000 {
8001 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8002 context->value = context->fromx;
8003 }
8004 public void Postx(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8005 {
8006 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8007 if (matched)
8008 {
8009 UniquePtr<Object> fromx_value = stack.Pop();
8010 context->fromx = *cast<ValueObject<byte>*>(fromx_value.Get());
8011 }
8012 }
8013 public class Context : System.Text.Parsing.Context
8014 {
8015 public Context() : value(), fromx()
8016 {
8017 }
8018 public byte value;
8019 public byte fromx;
8020 }
8021 }
8022
8023 public class ShortConstantRule : System.Text.Parsing.RuleParser
8024 {
8025 public ShortConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
8026 {
8027 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
8028 SetValueTypeName(ToUtf32("ConstantValue*"));
8029 }
8030 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
8031 {
8032 parsingData->PushContext(Id(), new Context());
8033 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8034 UniquePtr<Object> context_value = stack.Pop();
8035 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
8036 }
8037 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8038 {
8039 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8040 if (matched)
8041 {
8042 stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
8043 }
8044 parsingData->PopContext(Id());
8045 }
8046 public override void Link()
8047 {
8048 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
8049 a0ActionParser->SetAction(A0Action);
8050 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
8051 typeNonterminalParser->SetPre(Pretype);
8052 typeNonterminalParser->SetPost(Posttype);
8053 NonterminalParser* valNonterminalParser = GetNonterminal(ToUtf32("val"));
8054 valNonterminalParser->SetPost(Postval);
8055 }
8056 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
8057 {
8058 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8059 context->value = context->context->MakeShortValue(cast<ShortType*>(context->fromtype), context->fromval);
8060 }
8061 public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
8062 {
8063 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8064 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
8065 }
8066 public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8067 {
8068 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8069 if (matched)
8070 {
8071 UniquePtr<Object> fromtype_value = stack.Pop();
8072 context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
8073 }
8074 }
8075 public void Postval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8076 {
8077 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8078 if (matched)
8079 {
8080 UniquePtr<Object> fromval_value = stack.Pop();
8081 context->fromval = *cast<ValueObject<short>*>(fromval_value.Get());
8082 }
8083 }
8084 public class Context : System.Text.Parsing.Context
8085 {
8086 public Context() : context(), value(), fromtype(), fromval()
8087 {
8088 }
8089 public cmsx.intermediate.Context* context;
8090 public ConstantValue* value;
8091 public Type* fromtype;
8092 public short fromval;
8093 }
8094 }
8095
8096 public class ShortValueRule : System.Text.Parsing.RuleParser
8097 {
8098 public ShortValueRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
8099 {
8100 SetValueTypeName(ToUtf32("short"));
8101 }
8102 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
8103 {
8104 parsingData->PushContext(Id(), new Context());
8105 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8106 }
8107 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8108 {
8109 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8110 if (matched)
8111 {
8112 stack.Push(UniquePtr<Object>(new ValueObject<short>(context->value)));
8113 }
8114 parsingData->PopContext(Id());
8115 }
8116 public override void Link()
8117 {
8118 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
8119 a0ActionParser->SetAction(A0Action);
8120 NonterminalParser* xNonterminalParser = GetNonterminal(ToUtf32("x"));
8121 xNonterminalParser->SetPost(Postx);
8122 }
8123 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
8124 {
8125 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8126 context->value = context->fromx;
8127 }
8128 public void Postx(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8129 {
8130 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8131 if (matched)
8132 {
8133 UniquePtr<Object> fromx_value = stack.Pop();
8134 context->fromx = *cast<ValueObject<short>*>(fromx_value.Get());
8135 }
8136 }
8137 public class Context : System.Text.Parsing.Context
8138 {
8139 public Context() : value(), fromx()
8140 {
8141 }
8142 public short value;
8143 public short fromx;
8144 }
8145 }
8146
8147 public class UShortConstantRule : System.Text.Parsing.RuleParser
8148 {
8149 public UShortConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
8150 {
8151 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
8152 SetValueTypeName(ToUtf32("ConstantValue*"));
8153 }
8154 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
8155 {
8156 parsingData->PushContext(Id(), new Context());
8157 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8158 UniquePtr<Object> context_value = stack.Pop();
8159 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
8160 }
8161 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8162 {
8163 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8164 if (matched)
8165 {
8166 stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
8167 }
8168 parsingData->PopContext(Id());
8169 }
8170 public override void Link()
8171 {
8172 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
8173 a0ActionParser->SetAction(A0Action);
8174 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
8175 typeNonterminalParser->SetPre(Pretype);
8176 typeNonterminalParser->SetPost(Posttype);
8177 NonterminalParser* valNonterminalParser = GetNonterminal(ToUtf32("val"));
8178 valNonterminalParser->SetPost(Postval);
8179 }
8180 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
8181 {
8182 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8183 context->value = context->context->MakeUShortValue(cast<UShortType*>(context->fromtype), context->fromval);
8184 }
8185 public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
8186 {
8187 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8188 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
8189 }
8190 public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8191 {
8192 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8193 if (matched)
8194 {
8195 UniquePtr<Object> fromtype_value = stack.Pop();
8196 context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
8197 }
8198 }
8199 public void Postval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8200 {
8201 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8202 if (matched)
8203 {
8204 UniquePtr<Object> fromval_value = stack.Pop();
8205 context->fromval = *cast<ValueObject<ushort>*>(fromval_value.Get());
8206 }
8207 }
8208 public class Context : System.Text.Parsing.Context
8209 {
8210 public Context() : context(), value(), fromtype(), fromval()
8211 {
8212 }
8213 public cmsx.intermediate.Context* context;
8214 public ConstantValue* value;
8215 public Type* fromtype;
8216 public ushort fromval;
8217 }
8218 }
8219
8220 public class UShortValueRule : System.Text.Parsing.RuleParser
8221 {
8222 public UShortValueRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
8223 {
8224 SetValueTypeName(ToUtf32("ushort"));
8225 }
8226 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
8227 {
8228 parsingData->PushContext(Id(), new Context());
8229 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8230 }
8231 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8232 {
8233 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8234 if (matched)
8235 {
8236 stack.Push(UniquePtr<Object>(new ValueObject<ushort>(context->value)));
8237 }
8238 parsingData->PopContext(Id());
8239 }
8240 public override void Link()
8241 {
8242 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
8243 a0ActionParser->SetAction(A0Action);
8244 NonterminalParser* xNonterminalParser = GetNonterminal(ToUtf32("x"));
8245 xNonterminalParser->SetPost(Postx);
8246 }
8247 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
8248 {
8249 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8250 context->value = context->fromx;
8251 }
8252 public void Postx(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8253 {
8254 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8255 if (matched)
8256 {
8257 UniquePtr<Object> fromx_value = stack.Pop();
8258 context->fromx = *cast<ValueObject<ushort>*>(fromx_value.Get());
8259 }
8260 }
8261 public class Context : System.Text.Parsing.Context
8262 {
8263 public Context() : value(), fromx()
8264 {
8265 }
8266 public ushort value;
8267 public ushort fromx;
8268 }
8269 }
8270
8271 public class IntConstantRule : System.Text.Parsing.RuleParser
8272 {
8273 public IntConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
8274 {
8275 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
8276 SetValueTypeName(ToUtf32("ConstantValue*"));
8277 }
8278 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
8279 {
8280 parsingData->PushContext(Id(), new Context());
8281 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8282 UniquePtr<Object> context_value = stack.Pop();
8283 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
8284 }
8285 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8286 {
8287 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8288 if (matched)
8289 {
8290 stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
8291 }
8292 parsingData->PopContext(Id());
8293 }
8294 public override void Link()
8295 {
8296 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
8297 a0ActionParser->SetAction(A0Action);
8298 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
8299 typeNonterminalParser->SetPre(Pretype);
8300 typeNonterminalParser->SetPost(Posttype);
8301 NonterminalParser* valNonterminalParser = GetNonterminal(ToUtf32("val"));
8302 valNonterminalParser->SetPost(Postval);
8303 }
8304 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
8305 {
8306 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8307 context->value = context->context->MakeIntValue(cast<IntType*>(context->fromtype), context->fromval);
8308 }
8309 public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
8310 {
8311 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8312 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
8313 }
8314 public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8315 {
8316 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8317 if (matched)
8318 {
8319 UniquePtr<Object> fromtype_value = stack.Pop();
8320 context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
8321 }
8322 }
8323 public void Postval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8324 {
8325 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8326 if (matched)
8327 {
8328 UniquePtr<Object> fromval_value = stack.Pop();
8329 context->fromval = *cast<ValueObject<int>*>(fromval_value.Get());
8330 }
8331 }
8332 public class Context : System.Text.Parsing.Context
8333 {
8334 public Context() : context(), value(), fromtype(), fromval()
8335 {
8336 }
8337 public cmsx.intermediate.Context* context;
8338 public ConstantValue* value;
8339 public Type* fromtype;
8340 public int fromval;
8341 }
8342 }
8343
8344 public class IntValueRule : System.Text.Parsing.RuleParser
8345 {
8346 public IntValueRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
8347 {
8348 SetValueTypeName(ToUtf32("int"));
8349 }
8350 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
8351 {
8352 parsingData->PushContext(Id(), new Context());
8353 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8354 }
8355 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8356 {
8357 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8358 if (matched)
8359 {
8360 stack.Push(UniquePtr<Object>(new ValueObject<int>(context->value)));
8361 }
8362 parsingData->PopContext(Id());
8363 }
8364 public override void Link()
8365 {
8366 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
8367 a0ActionParser->SetAction(A0Action);
8368 NonterminalParser* xNonterminalParser = GetNonterminal(ToUtf32("x"));
8369 xNonterminalParser->SetPost(Postx);
8370 }
8371 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
8372 {
8373 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8374 context->value = context->fromx;
8375 }
8376 public void Postx(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8377 {
8378 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8379 if (matched)
8380 {
8381 UniquePtr<Object> fromx_value = stack.Pop();
8382 context->fromx = *cast<ValueObject<int>*>(fromx_value.Get());
8383 }
8384 }
8385 public class Context : System.Text.Parsing.Context
8386 {
8387 public Context() : value(), fromx()
8388 {
8389 }
8390 public int value;
8391 public int fromx;
8392 }
8393 }
8394
8395 public class UIntConstantRule : System.Text.Parsing.RuleParser
8396 {
8397 public UIntConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
8398 {
8399 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
8400 SetValueTypeName(ToUtf32("ConstantValue*"));
8401 }
8402 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
8403 {
8404 parsingData->PushContext(Id(), new Context());
8405 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8406 UniquePtr<Object> context_value = stack.Pop();
8407 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
8408 }
8409 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8410 {
8411 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8412 if (matched)
8413 {
8414 stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
8415 }
8416 parsingData->PopContext(Id());
8417 }
8418 public override void Link()
8419 {
8420 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
8421 a0ActionParser->SetAction(A0Action);
8422 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
8423 typeNonterminalParser->SetPre(Pretype);
8424 typeNonterminalParser->SetPost(Posttype);
8425 NonterminalParser* valNonterminalParser = GetNonterminal(ToUtf32("val"));
8426 valNonterminalParser->SetPost(Postval);
8427 }
8428 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
8429 {
8430 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8431 context->value = context->context->MakeUIntValue(cast<UIntType*>(context->fromtype), context->fromval);
8432 }
8433 public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
8434 {
8435 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8436 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
8437 }
8438 public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8439 {
8440 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8441 if (matched)
8442 {
8443 UniquePtr<Object> fromtype_value = stack.Pop();
8444 context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
8445 }
8446 }
8447 public void Postval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8448 {
8449 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8450 if (matched)
8451 {
8452 UniquePtr<Object> fromval_value = stack.Pop();
8453 context->fromval = *cast<ValueObject<uint>*>(fromval_value.Get());
8454 }
8455 }
8456 public class Context : System.Text.Parsing.Context
8457 {
8458 public Context() : context(), value(), fromtype(), fromval()
8459 {
8460 }
8461 public cmsx.intermediate.Context* context;
8462 public ConstantValue* value;
8463 public Type* fromtype;
8464 public uint fromval;
8465 }
8466 }
8467
8468 public class UIntValueRule : System.Text.Parsing.RuleParser
8469 {
8470 public UIntValueRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
8471 {
8472 SetValueTypeName(ToUtf32("uint"));
8473 }
8474 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
8475 {
8476 parsingData->PushContext(Id(), new Context());
8477 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8478 }
8479 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8480 {
8481 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8482 if (matched)
8483 {
8484 stack.Push(UniquePtr<Object>(new ValueObject<uint>(context->value)));
8485 }
8486 parsingData->PopContext(Id());
8487 }
8488 public override void Link()
8489 {
8490 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
8491 a0ActionParser->SetAction(A0Action);
8492 NonterminalParser* xNonterminalParser = GetNonterminal(ToUtf32("x"));
8493 xNonterminalParser->SetPost(Postx);
8494 }
8495 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
8496 {
8497 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8498 context->value = context->fromx;
8499 }
8500 public void Postx(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8501 {
8502 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8503 if (matched)
8504 {
8505 UniquePtr<Object> fromx_value = stack.Pop();
8506 context->fromx = *cast<ValueObject<uint>*>(fromx_value.Get());
8507 }
8508 }
8509 public class Context : System.Text.Parsing.Context
8510 {
8511 public Context() : value(), fromx()
8512 {
8513 }
8514 public uint value;
8515 public uint fromx;
8516 }
8517 }
8518
8519 public class LongConstantRule : System.Text.Parsing.RuleParser
8520 {
8521 public LongConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
8522 {
8523 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
8524 SetValueTypeName(ToUtf32("ConstantValue*"));
8525 }
8526 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
8527 {
8528 parsingData->PushContext(Id(), new Context());
8529 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8530 UniquePtr<Object> context_value = stack.Pop();
8531 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
8532 }
8533 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8534 {
8535 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8536 if (matched)
8537 {
8538 stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
8539 }
8540 parsingData->PopContext(Id());
8541 }
8542 public override void Link()
8543 {
8544 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
8545 a0ActionParser->SetAction(A0Action);
8546 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
8547 typeNonterminalParser->SetPre(Pretype);
8548 typeNonterminalParser->SetPost(Posttype);
8549 NonterminalParser* valNonterminalParser = GetNonterminal(ToUtf32("val"));
8550 valNonterminalParser->SetPost(Postval);
8551 }
8552 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
8553 {
8554 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8555 context->value = context->context->MakeLongValue(cast<LongType*>(context->fromtype), context->fromval);
8556 }
8557 public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
8558 {
8559 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8560 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
8561 }
8562 public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8563 {
8564 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8565 if (matched)
8566 {
8567 UniquePtr<Object> fromtype_value = stack.Pop();
8568 context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
8569 }
8570 }
8571 public void Postval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8572 {
8573 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8574 if (matched)
8575 {
8576 UniquePtr<Object> fromval_value = stack.Pop();
8577 context->fromval = *cast<ValueObject<long>*>(fromval_value.Get());
8578 }
8579 }
8580 public class Context : System.Text.Parsing.Context
8581 {
8582 public Context() : context(), value(), fromtype(), fromval()
8583 {
8584 }
8585 public cmsx.intermediate.Context* context;
8586 public ConstantValue* value;
8587 public Type* fromtype;
8588 public long fromval;
8589 }
8590 }
8591
8592 public class LongValueRule : System.Text.Parsing.RuleParser
8593 {
8594 public LongValueRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
8595 {
8596 SetValueTypeName(ToUtf32("long"));
8597 }
8598 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
8599 {
8600 parsingData->PushContext(Id(), new Context());
8601 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8602 }
8603 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8604 {
8605 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8606 if (matched)
8607 {
8608 stack.Push(UniquePtr<Object>(new ValueObject<long>(context->value)));
8609 }
8610 parsingData->PopContext(Id());
8611 }
8612 public override void Link()
8613 {
8614 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
8615 a0ActionParser->SetAction(A0Action);
8616 NonterminalParser* xNonterminalParser = GetNonterminal(ToUtf32("x"));
8617 xNonterminalParser->SetPost(Postx);
8618 }
8619 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
8620 {
8621 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8622 context->value = context->fromx;
8623 }
8624 public void Postx(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8625 {
8626 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8627 if (matched)
8628 {
8629 UniquePtr<Object> fromx_value = stack.Pop();
8630 context->fromx = *cast<ValueObject<long>*>(fromx_value.Get());
8631 }
8632 }
8633 public class Context : System.Text.Parsing.Context
8634 {
8635 public Context() : value(), fromx()
8636 {
8637 }
8638 public long value;
8639 public long fromx;
8640 }
8641 }
8642
8643 public class ULongConstantRule : System.Text.Parsing.RuleParser
8644 {
8645 public ULongConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
8646 {
8647 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
8648 SetValueTypeName(ToUtf32("ConstantValue*"));
8649 }
8650 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
8651 {
8652 parsingData->PushContext(Id(), new Context());
8653 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8654 UniquePtr<Object> context_value = stack.Pop();
8655 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
8656 }
8657 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8658 {
8659 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8660 if (matched)
8661 {
8662 stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
8663 }
8664 parsingData->PopContext(Id());
8665 }
8666 public override void Link()
8667 {
8668 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
8669 a0ActionParser->SetAction(A0Action);
8670 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
8671 typeNonterminalParser->SetPre(Pretype);
8672 typeNonterminalParser->SetPost(Posttype);
8673 NonterminalParser* valNonterminalParser = GetNonterminal(ToUtf32("val"));
8674 valNonterminalParser->SetPost(Postval);
8675 }
8676 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
8677 {
8678 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8679 context->value = context->context->MakeULongValue(cast<ULongType*>(context->fromtype), context->fromval);
8680 }
8681 public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
8682 {
8683 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8684 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
8685 }
8686 public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8687 {
8688 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8689 if (matched)
8690 {
8691 UniquePtr<Object> fromtype_value = stack.Pop();
8692 context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
8693 }
8694 }
8695 public void Postval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8696 {
8697 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8698 if (matched)
8699 {
8700 UniquePtr<Object> fromval_value = stack.Pop();
8701 context->fromval = *cast<ValueObject<ulong>*>(fromval_value.Get());
8702 }
8703 }
8704 public class Context : System.Text.Parsing.Context
8705 {
8706 public Context() : context(), value(), fromtype(), fromval()
8707 {
8708 }
8709 public cmsx.intermediate.Context* context;
8710 public ConstantValue* value;
8711 public Type* fromtype;
8712 public ulong fromval;
8713 }
8714 }
8715
8716 public class ULongValueRule : System.Text.Parsing.RuleParser
8717 {
8718 public ULongValueRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
8719 {
8720 SetValueTypeName(ToUtf32("ulong"));
8721 }
8722 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
8723 {
8724 parsingData->PushContext(Id(), new Context());
8725 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8726 }
8727 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8728 {
8729 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8730 if (matched)
8731 {
8732 stack.Push(UniquePtr<Object>(new ValueObject<ulong>(context->value)));
8733 }
8734 parsingData->PopContext(Id());
8735 }
8736 public override void Link()
8737 {
8738 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
8739 a0ActionParser->SetAction(A0Action);
8740 NonterminalParser* xNonterminalParser = GetNonterminal(ToUtf32("x"));
8741 xNonterminalParser->SetPost(Postx);
8742 }
8743 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
8744 {
8745 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8746 context->value = context->fromx;
8747 }
8748 public void Postx(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8749 {
8750 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8751 if (matched)
8752 {
8753 UniquePtr<Object> fromx_value = stack.Pop();
8754 context->fromx = *cast<ValueObject<ulong>*>(fromx_value.Get());
8755 }
8756 }
8757 public class Context : System.Text.Parsing.Context
8758 {
8759 public Context() : value(), fromx()
8760 {
8761 }
8762 public ulong value;
8763 public ulong fromx;
8764 }
8765 }
8766
8767 public class FloatConstantRule : System.Text.Parsing.RuleParser
8768 {
8769 public FloatConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
8770 {
8771 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
8772 SetValueTypeName(ToUtf32("ConstantValue*"));
8773 }
8774 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
8775 {
8776 parsingData->PushContext(Id(), new Context());
8777 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8778 UniquePtr<Object> context_value = stack.Pop();
8779 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
8780 }
8781 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8782 {
8783 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8784 if (matched)
8785 {
8786 stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
8787 }
8788 parsingData->PopContext(Id());
8789 }
8790 public override void Link()
8791 {
8792 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
8793 a0ActionParser->SetAction(A0Action);
8794 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
8795 typeNonterminalParser->SetPre(Pretype);
8796 typeNonterminalParser->SetPost(Posttype);
8797 NonterminalParser* valNonterminalParser = GetNonterminal(ToUtf32("val"));
8798 valNonterminalParser->SetPost(Postval);
8799 }
8800 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
8801 {
8802 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8803 context->value = context->context->MakeFloatValue(cast<FloatType*>(context->fromtype), context->fromval);
8804 }
8805 public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
8806 {
8807 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8808 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
8809 }
8810 public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8811 {
8812 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8813 if (matched)
8814 {
8815 UniquePtr<Object> fromtype_value = stack.Pop();
8816 context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
8817 }
8818 }
8819 public void Postval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8820 {
8821 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8822 if (matched)
8823 {
8824 UniquePtr<Object> fromval_value = stack.Pop();
8825 context->fromval = *cast<ValueObject<float>*>(fromval_value.Get());
8826 }
8827 }
8828 public class Context : System.Text.Parsing.Context
8829 {
8830 public Context() : context(), value(), fromtype(), fromval()
8831 {
8832 }
8833 public cmsx.intermediate.Context* context;
8834 public ConstantValue* value;
8835 public Type* fromtype;
8836 public float fromval;
8837 }
8838 }
8839
8840 public class FloatValueRule : System.Text.Parsing.RuleParser
8841 {
8842 public FloatValueRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
8843 {
8844 SetValueTypeName(ToUtf32("float"));
8845 }
8846 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
8847 {
8848 parsingData->PushContext(Id(), new Context());
8849 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8850 }
8851 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8852 {
8853 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8854 if (matched)
8855 {
8856 stack.Push(UniquePtr<Object>(new ValueObject<float>(context->value)));
8857 }
8858 parsingData->PopContext(Id());
8859 }
8860 public override void Link()
8861 {
8862 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
8863 a0ActionParser->SetAction(A0Action);
8864 NonterminalParser* xNonterminalParser = GetNonterminal(ToUtf32("x"));
8865 xNonterminalParser->SetPost(Postx);
8866 }
8867 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
8868 {
8869 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8870 context->value = context->fromx;
8871 }
8872 public void Postx(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8873 {
8874 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8875 if (matched)
8876 {
8877 UniquePtr<Object> fromx_value = stack.Pop();
8878 context->fromx = *cast<ValueObject<float>*>(fromx_value.Get());
8879 }
8880 }
8881 public class Context : System.Text.Parsing.Context
8882 {
8883 public Context() : value(), fromx()
8884 {
8885 }
8886 public float value;
8887 public float fromx;
8888 }
8889 }
8890
8891 public class DoubleConstantRule : System.Text.Parsing.RuleParser
8892 {
8893 public DoubleConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
8894 {
8895 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
8896 SetValueTypeName(ToUtf32("ConstantValue*"));
8897 }
8898 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
8899 {
8900 parsingData->PushContext(Id(), new Context());
8901 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8902 UniquePtr<Object> context_value = stack.Pop();
8903 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
8904 }
8905 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8906 {
8907 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8908 if (matched)
8909 {
8910 stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
8911 }
8912 parsingData->PopContext(Id());
8913 }
8914 public override void Link()
8915 {
8916 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
8917 a0ActionParser->SetAction(A0Action);
8918 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
8919 typeNonterminalParser->SetPre(Pretype);
8920 typeNonterminalParser->SetPost(Posttype);
8921 NonterminalParser* valNonterminalParser = GetNonterminal(ToUtf32("val"));
8922 valNonterminalParser->SetPost(Postval);
8923 }
8924 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
8925 {
8926 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8927 context->value = context->context->MakeDoubleValue(cast<DoubleType*>(context->fromtype), context->fromval);
8928 }
8929 public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
8930 {
8931 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8932 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
8933 }
8934 public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8935 {
8936 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8937 if (matched)
8938 {
8939 UniquePtr<Object> fromtype_value = stack.Pop();
8940 context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
8941 }
8942 }
8943 public void Postval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8944 {
8945 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8946 if (matched)
8947 {
8948 UniquePtr<Object> fromval_value = stack.Pop();
8949 context->fromval = *cast<ValueObject<double>*>(fromval_value.Get());
8950 }
8951 }
8952 public class Context : System.Text.Parsing.Context
8953 {
8954 public Context() : context(), value(), fromtype(), fromval()
8955 {
8956 }
8957 public cmsx.intermediate.Context* context;
8958 public ConstantValue* value;
8959 public Type* fromtype;
8960 public double fromval;
8961 }
8962 }
8963
8964 public class DoubleValueRule : System.Text.Parsing.RuleParser
8965 {
8966 public DoubleValueRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
8967 {
8968 SetValueTypeName(ToUtf32("double"));
8969 }
8970 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
8971 {
8972 parsingData->PushContext(Id(), new Context());
8973 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8974 }
8975 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8976 {
8977 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8978 if (matched)
8979 {
8980 stack.Push(UniquePtr<Object>(new ValueObject<double>(context->value)));
8981 }
8982 parsingData->PopContext(Id());
8983 }
8984 public override void Link()
8985 {
8986 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
8987 a0ActionParser->SetAction(A0Action);
8988 NonterminalParser* xNonterminalParser = GetNonterminal(ToUtf32("x"));
8989 xNonterminalParser->SetPost(Postx);
8990 }
8991 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
8992 {
8993 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8994 context->value = context->fromx;
8995 }
8996 public void Postx(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8997 {
8998 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8999 if (matched)
9000 {
9001 UniquePtr<Object> fromx_value = stack.Pop();
9002 context->fromx = *cast<ValueObject<double>*>(fromx_value.Get());
9003 }
9004 }
9005 public class Context : System.Text.Parsing.Context
9006 {
9007 public Context() : value(), fromx()
9008 {
9009 }
9010 public double value;
9011 public double fromx;
9012 }
9013 }
9014
9015 public class ConversionConstantRule : System.Text.Parsing.RuleParser
9016 {
9017 public ConversionConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
9018 {
9019 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
9020 SetValueTypeName(ToUtf32("ConstantValue*"));
9021 }
9022 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
9023 {
9024 parsingData->PushContext(Id(), new Context());
9025 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9026 UniquePtr<Object> context_value = stack.Pop();
9027 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
9028 }
9029 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
9030 {
9031 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9032 if (matched)
9033 {
9034 stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
9035 }
9036 parsingData->PopContext(Id());
9037 }
9038 public override void Link()
9039 {
9040 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
9041 a0ActionParser->SetAction(A0Action);
9042 NonterminalParser* targetTypeNonterminalParser = GetNonterminal(ToUtf32("targetType"));
9043 targetTypeNonterminalParser->SetPre(PretargetType);
9044 targetTypeNonterminalParser->SetPost(PosttargetType);
9045 NonterminalParser* fromNonterminalParser = GetNonterminal(ToUtf32("from"));
9046 fromNonterminalParser->SetPre(Prefrom);
9047 fromNonterminalParser->SetPost(Postfrom);
9048 }
9049 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
9050 {
9051 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9052 context->value = context->context->MakeConversionValue(context->fromtargetType, context->fromfrom, span.lineNumber);
9053 }
9054 public void PretargetType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
9055 {
9056 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9057 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
9058 }
9059 public void PosttargetType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
9060 {
9061 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9062 if (matched)
9063 {
9064 UniquePtr<Object> fromtargetType_value = stack.Pop();
9065 context->fromtargetType = *cast<ValueObject<Type*>*>(fromtargetType_value.Get());
9066 }
9067 }
9068 public void Prefrom(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
9069 {
9070 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9071 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
9072 }
9073 public void Postfrom(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
9074 {
9075 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9076 if (matched)
9077 {
9078 UniquePtr<Object> fromfrom_value = stack.Pop();
9079 context->fromfrom = *cast<ValueObject<ConstantValue*>*>(fromfrom_value.Get());
9080 }
9081 }
9082 public class Context : System.Text.Parsing.Context
9083 {
9084 public Context() : context(), value(), fromtargetType(), fromfrom()
9085 {
9086 }
9087 public cmsx.intermediate.Context* context;
9088 public ConstantValue* value;
9089 public Type* fromtargetType;
9090 public ConstantValue* fromfrom;
9091 }
9092 }
9093
9094 public class ClsIdConstantRule : System.Text.Parsing.RuleParser
9095 {
9096 public ClsIdConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
9097 {
9098 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
9099 SetValueTypeName(ToUtf32("ConstantValue*"));
9100 }
9101 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
9102 {
9103 parsingData->PushContext(Id(), new Context());
9104 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9105 UniquePtr<Object> context_value = stack.Pop();
9106 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
9107 }
9108 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
9109 {
9110 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9111 if (matched)
9112 {
9113 stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
9114 }
9115 parsingData->PopContext(Id());
9116 }
9117 public override void Link()
9118 {
9119 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
9120 a0ActionParser->SetAction(A0Action);
9121 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
9122 typeNonterminalParser->SetPre(Pretype);
9123 typeNonterminalParser->SetPost(Posttype);
9124 }
9125 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
9126 {
9127 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9128 context->value = context->context->MakeClsIdValue(context->fromtype, ToUtf8(ustring(matchBegin, matchEnd)), span.lineNumber);
9129 }
9130 public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
9131 {
9132 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9133 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
9134 }
9135 public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
9136 {
9137 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9138 if (matched)
9139 {
9140 UniquePtr<Object> fromtype_value = stack.Pop();
9141 context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
9142 }
9143 }
9144 public class Context : System.Text.Parsing.Context
9145 {
9146 public Context() : context(), value(), fromtype()
9147 {
9148 }
9149 public cmsx.intermediate.Context* context;
9150 public ConstantValue* value;
9151 public Type* fromtype;
9152 }
9153 }
9154
9155 public class PtrConstantRule : System.Text.Parsing.RuleParser
9156 {
9157 public PtrConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
9158 {
9159 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
9160 SetValueTypeName(ToUtf32("ConstantValue*"));
9161 }
9162 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
9163 {
9164 parsingData->PushContext(Id(), new Context());
9165 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9166 UniquePtr<Object> context_value = stack.Pop();
9167 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
9168 }
9169 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
9170 {
9171 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9172 if (matched)
9173 {
9174 stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
9175 }
9176 parsingData->PopContext(Id());
9177 }
9178 public override void Link()
9179 {
9180 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
9181 a0ActionParser->SetAction(A0Action);
9182 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
9183 a1ActionParser->SetAction(A1Action);
9184 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
9185 a2ActionParser->SetAction(A2Action);
9186 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
9187 a3ActionParser->SetAction(A3Action);
9188 NonterminalParser* type1NonterminalParser = GetNonterminal(ToUtf32("type1"));
9189 type1NonterminalParser->SetPre(Pretype1);
9190 type1NonterminalParser->SetPost(Posttype1);
9191 NonterminalParser* type2NonterminalParser = GetNonterminal(ToUtf32("type2"));
9192 type2NonterminalParser->SetPre(Pretype2);
9193 type2NonterminalParser->SetPost(Posttype2);
9194 NonterminalParser* literalValueNonterminalParser = GetNonterminal(ToUtf32("LiteralValue"));
9195 literalValueNonterminalParser->SetPre(PreLiteralValue);
9196 literalValueNonterminalParser->SetPost(PostLiteralValue);
9197 }
9198 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
9199 {
9200 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9201 context->value = cast<PtrType*>(context->fromtype1)->DefaultValue();
9202 }
9203 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
9204 {
9205 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9206 pass = IsPtrType(context->fromtype1);
9207 }
9208 public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
9209 {
9210 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9211 context->value = context->fromLiteralValue;
9212 }
9213 public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
9214 {
9215 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9216 pass = IsPtrType(context->fromtype2);
9217 }
9218 public void Pretype1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
9219 {
9220 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9221 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
9222 }
9223 public void Posttype1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
9224 {
9225 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9226 if (matched)
9227 {
9228 UniquePtr<Object> fromtype1_value = stack.Pop();
9229 context->fromtype1 = *cast<ValueObject<Type*>*>(fromtype1_value.Get());
9230 }
9231 }
9232 public void Pretype2(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
9233 {
9234 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9235 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
9236 }
9237 public void Posttype2(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
9238 {
9239 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9240 if (matched)
9241 {
9242 UniquePtr<Object> fromtype2_value = stack.Pop();
9243 context->fromtype2 = *cast<ValueObject<Type*>*>(fromtype2_value.Get());
9244 }
9245 }
9246 public void PreLiteralValue(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
9247 {
9248 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9249 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
9250 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->fromtype2)));
9251 }
9252 public void PostLiteralValue(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
9253 {
9254 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9255 if (matched)
9256 {
9257 UniquePtr<Object> fromLiteralValue_value = stack.Pop();
9258 context->fromLiteralValue = *cast<ValueObject<ConstantValue*>*>(fromLiteralValue_value.Get());
9259 }
9260 }
9261 public class Context : System.Text.Parsing.Context
9262 {
9263 public Context() : context(), value(), fromtype1(), fromtype2(), fromLiteralValue()
9264 {
9265 }
9266 public cmsx.intermediate.Context* context;
9267 public ConstantValue* value;
9268 public Type* fromtype1;
9269 public Type* fromtype2;
9270 public ConstantValue* fromLiteralValue;
9271 }
9272 }
9273
9274 public class SymbolConstantRule : System.Text.Parsing.RuleParser
9275 {
9276 public SymbolConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
9277 {
9278 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
9279 SetValueTypeName(ToUtf32("ConstantValue*"));
9280 }
9281 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
9282 {
9283 parsingData->PushContext(Id(), new Context());
9284 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9285 UniquePtr<Object> context_value = stack.Pop();
9286 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
9287 }
9288 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
9289 {
9290 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9291 if (matched)
9292 {
9293 stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
9294 }
9295 parsingData->PopContext(Id());
9296 }
9297 public override void Link()
9298 {
9299 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
9300 a0ActionParser->SetAction(A0Action);
9301 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
9302 typeNonterminalParser->SetPre(Pretype);
9303 typeNonterminalParser->SetPost(Posttype);
9304 NonterminalParser* symbolValueNonterminalParser = GetNonterminal(ToUtf32("SymbolValue"));
9305 symbolValueNonterminalParser->SetPre(PreSymbolValue);
9306 symbolValueNonterminalParser->SetPost(PostSymbolValue);
9307 }
9308 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
9309 {
9310 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9311 context->value = context->fromSymbolValue;
9312 }
9313 public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
9314 {
9315 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9316 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
9317 }
9318 public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
9319 {
9320 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9321 if (matched)
9322 {
9323 UniquePtr<Object> fromtype_value = stack.Pop();
9324 context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
9325 }
9326 }
9327 public void PreSymbolValue(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
9328 {
9329 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9330 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
9331 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->fromtype)));
9332 }
9333 public void PostSymbolValue(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
9334 {
9335 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9336 if (matched)
9337 {
9338 UniquePtr<Object> fromSymbolValue_value = stack.Pop();
9339 context->fromSymbolValue = *cast<ValueObject<ConstantValue*>*>(fromSymbolValue_value.Get());
9340 }
9341 }
9342 public class Context : System.Text.Parsing.Context
9343 {
9344 public Context() : context(), value(), fromtype(), fromSymbolValue()
9345 {
9346 }
9347 public cmsx.intermediate.Context* context;
9348 public ConstantValue* value;
9349 public Type* fromtype;
9350 public ConstantValue* fromSymbolValue;
9351 }
9352 }
9353
9354 public class ArrayConstantRule : System.Text.Parsing.RuleParser
9355 {
9356 public ArrayConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
9357 {
9358 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
9359 SetValueTypeName(ToUtf32("ArrayValue*"));
9360 }
9361 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
9362 {
9363 parsingData->PushContext(Id(), new Context());
9364 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9365 UniquePtr<Object> context_value = stack.Pop();
9366 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
9367 }
9368 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
9369 {
9370 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9371 if (matched)
9372 {
9373 stack.Push(UniquePtr<Object>(new ValueObject<ArrayValue*>(context->value)));
9374 }
9375 parsingData->PopContext(Id());
9376 }
9377 public override void Link()
9378 {
9379 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
9380 a0ActionParser->SetAction(A0Action);
9381 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
9382 a1ActionParser->SetAction(A1Action);
9383 NonterminalParser* elementNonterminalParser = GetNonterminal(ToUtf32("element"));
9384 elementNonterminalParser->SetPre(Preelement);
9385 elementNonterminalParser->SetPost(Postelement);
9386 }
9387 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
9388 {
9389 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9390 context->value = context->context->MakeArrayValue();
9391 }
9392 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
9393 {
9394 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9395 context->value->AddElement(context->fromelement);
9396 }
9397 public void Preelement(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
9398 {
9399 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9400 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
9401 }
9402 public void Postelement(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
9403 {
9404 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9405 if (matched)
9406 {
9407 UniquePtr<Object> fromelement_value = stack.Pop();
9408 context->fromelement = *cast<ValueObject<ConstantValue*>*>(fromelement_value.Get());
9409 }
9410 }
9411 public class Context : System.Text.Parsing.Context
9412 {
9413 public Context() : context(), value(), fromelement()
9414 {
9415 }
9416 public cmsx.intermediate.Context* context;
9417 public ArrayValue* value;
9418 public ConstantValue* fromelement;
9419 }
9420 }
9421
9422 public class StructureConstantRule : System.Text.Parsing.RuleParser
9423 {
9424 public StructureConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
9425 {
9426 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
9427 SetValueTypeName(ToUtf32("StructureValue*"));
9428 }
9429 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
9430 {
9431 parsingData->PushContext(Id(), new Context());
9432 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9433 UniquePtr<Object> context_value = stack.Pop();
9434 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
9435 }
9436 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
9437 {
9438 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9439 if (matched)
9440 {
9441 stack.Push(UniquePtr<Object>(new ValueObject<StructureValue*>(context->value)));
9442 }
9443 parsingData->PopContext(Id());
9444 }
9445 public override void Link()
9446 {
9447 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
9448 a0ActionParser->SetAction(A0Action);
9449 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
9450 a1ActionParser->SetAction(A1Action);
9451 NonterminalParser* memberNonterminalParser = GetNonterminal(ToUtf32("member"));
9452 memberNonterminalParser->SetPre(Premember);
9453 memberNonterminalParser->SetPost(Postmember);
9454 }
9455 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
9456 {
9457 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9458 context->value = context->context->MakeStructureValue();
9459 }
9460 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
9461 {
9462 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9463 context->value->AddMember(context->frommember);
9464 }
9465 public void Premember(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
9466 {
9467 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9468 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
9469 }
9470 public void Postmember(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
9471 {
9472 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9473 if (matched)
9474 {
9475 UniquePtr<Object> frommember_value = stack.Pop();
9476 context->frommember = *cast<ValueObject<ConstantValue*>*>(frommember_value.Get());
9477 }
9478 }
9479 public class Context : System.Text.Parsing.Context
9480 {
9481 public Context() : context(), value(), frommember()
9482 {
9483 }
9484 public cmsx.intermediate.Context* context;
9485 public StructureValue* value;
9486 public ConstantValue* frommember;
9487 }
9488 }
9489
9490 public class StringConstantRule : System.Text.Parsing.RuleParser
9491 {
9492 public StringConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
9493 {
9494 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
9495 SetValueTypeName(ToUtf32("StringValue*"));
9496 }
9497 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
9498 {
9499 parsingData->PushContext(Id(), new Context());
9500 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9501 UniquePtr<Object> context_value = stack.Pop();
9502 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
9503 }
9504 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
9505 {
9506 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9507 if (matched)
9508 {
9509 stack.Push(UniquePtr<Object>(new ValueObject<StringValue*>(context->value)));
9510 }
9511 parsingData->PopContext(Id());
9512 }
9513 public override void Link()
9514 {
9515 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
9516 a0ActionParser->SetAction(A0Action);
9517 }
9518 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
9519 {
9520 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9521 context->value = context->context->MakeStringValue(ToUtf8(ustring(matchBegin, matchEnd)));
9522 }
9523 public class Context : System.Text.Parsing.Context
9524 {
9525 public Context() : context(), value()
9526 {
9527 }
9528 public cmsx.intermediate.Context* context;
9529 public StringValue* value;
9530 }
9531 }
9532
9533 public class StringArrayConstantRule : System.Text.Parsing.RuleParser
9534 {
9535 public StringArrayConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
9536 {
9537 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
9538 SetValueTypeName(ToUtf32("StringArrayValue*"));
9539 }
9540 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
9541 {
9542 parsingData->PushContext(Id(), new Context());
9543 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9544 UniquePtr<Object> context_value = stack.Pop();
9545 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
9546 }
9547 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
9548 {
9549 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9550 if (matched)
9551 {
9552 stack.Push(UniquePtr<Object>(new ValueObject<StringArrayValue*>(context->value)));
9553 }
9554 parsingData->PopContext(Id());
9555 }
9556 public override void Link()
9557 {
9558 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
9559 a0ActionParser->SetAction(A0Action);
9560 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
9561 a1ActionParser->SetAction(A1Action);
9562 NonterminalParser* prefixNonterminalParser = GetNonterminal(ToUtf32("prefix"));
9563 prefixNonterminalParser->SetPost(Postprefix);
9564 NonterminalParser* elementNonterminalParser = GetNonterminal(ToUtf32("element"));
9565 elementNonterminalParser->SetPre(Preelement);
9566 elementNonterminalParser->SetPost(Postelement);
9567 }
9568 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
9569 {
9570 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9571 context->value = context->context->MakeStringArrayValue(context->fromprefix);
9572 }
9573 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
9574 {
9575 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9576 context->value->AddElement(context->fromelement);
9577 }
9578 public void Postprefix(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
9579 {
9580 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9581 if (matched)
9582 {
9583 UniquePtr<Object> fromprefix_value = stack.Pop();
9584 context->fromprefix = *cast<ValueObject<char>*>(fromprefix_value.Get());
9585 }
9586 }
9587 public void Preelement(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
9588 {
9589 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9590 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
9591 }
9592 public void Postelement(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
9593 {
9594 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9595 if (matched)
9596 {
9597 UniquePtr<Object> fromelement_value = stack.Pop();
9598 context->fromelement = *cast<ValueObject<ConstantValue*>*>(fromelement_value.Get());
9599 }
9600 }
9601 public class Context : System.Text.Parsing.Context
9602 {
9603 public Context() : context(), value(), fromprefix(), fromelement()
9604 {
9605 }
9606 public cmsx.intermediate.Context* context;
9607 public StringArrayValue* value;
9608 public char fromprefix;
9609 public ConstantValue* fromelement;
9610 }
9611 }
9612
9613 public class StringArrayPrefixRule : System.Text.Parsing.RuleParser
9614 {
9615 public StringArrayPrefixRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
9616 {
9617 SetValueTypeName(ToUtf32("char"));
9618 }
9619 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
9620 {
9621 parsingData->PushContext(Id(), new Context());
9622 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9623 }
9624 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
9625 {
9626 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9627 if (matched)
9628 {
9629 stack.Push(UniquePtr<Object>(new ValueObject<char>(context->value)));
9630 }
9631 parsingData->PopContext(Id());
9632 }
9633 public override void Link()
9634 {
9635 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
9636 a0ActionParser->SetAction(A0Action);
9637 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
9638 a1ActionParser->SetAction(A1Action);
9639 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
9640 a2ActionParser->SetAction(A2Action);
9641 }
9642 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
9643 {
9644 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9645 context->value = 'w';
9646 }
9647 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
9648 {
9649 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9650 context->value = 'u';
9651 }
9652 public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
9653 {
9654 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9655 context->value = 'b';
9656 }
9657 public class Context : System.Text.Parsing.Context
9658 {
9659 public Context() : value()
9660 {
9661 }
9662 public char value;
9663 }
9664 }
9665
9666 public class MetadataRule : System.Text.Parsing.RuleParser
9667 {
9668 public MetadataRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
9669 {
9670 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
9671 }
9672 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
9673 {
9674 parsingData->PushContext(Id(), new Context());
9675 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9676 UniquePtr<Object> context_value = stack.Pop();
9677 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
9678 }
9679 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
9680 {
9681 parsingData->PopContext(Id());
9682 }
9683 public override void Link()
9684 {
9685 NonterminalParser* mDStructNonterminalParser = GetNonterminal(ToUtf32("MDStruct"));
9686 mDStructNonterminalParser->SetPre(PreMDStruct);
9687 mDStructNonterminalParser->SetPost(PostMDStruct);
9688 }
9689 public void PreMDStruct(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
9690 {
9691 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9692 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
9693 }
9694 public void PostMDStruct(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
9695 {
9696 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9697 if (matched)
9698 {
9699 UniquePtr<Object> fromMDStruct_value = stack.Pop();
9700 context->fromMDStruct = *cast<ValueObject<MDStruct*>*>(fromMDStruct_value.Get());
9701 }
9702 }
9703 public class Context : System.Text.Parsing.Context
9704 {
9705 public Context() : context(), fromMDStruct()
9706 {
9707 }
9708 public cmsx.intermediate.Context* context;
9709 public MDStruct* fromMDStruct;
9710 }
9711 }
9712
9713 public class MDItemRule : System.Text.Parsing.RuleParser
9714 {
9715 public MDItemRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
9716 {
9717 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
9718 SetValueTypeName(ToUtf32("MDItem*"));
9719 }
9720 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
9721 {
9722 parsingData->PushContext(Id(), new Context());
9723 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9724 UniquePtr<Object> context_value = stack.Pop();
9725 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
9726 }
9727 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
9728 {
9729 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9730 if (matched)
9731 {
9732 stack.Push(UniquePtr<Object>(new ValueObject<MDItem*>(context->value)));
9733 }
9734 parsingData->PopContext(Id());
9735 }
9736 public override void Link()
9737 {
9738 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
9739 a0ActionParser->SetAction(A0Action);
9740 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
9741 a1ActionParser->SetAction(A1Action);
9742 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
9743 a2ActionParser->SetAction(A2Action);
9744 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
9745 a3ActionParser->SetAction(A3Action);
9746 NonterminalParser* mDBoolNonterminalParser = GetNonterminal(ToUtf32("MDBool"));
9747 mDBoolNonterminalParser->SetPre(PreMDBool);
9748 mDBoolNonterminalParser->SetPost(PostMDBool);
9749 NonterminalParser* mDLongNonterminalParser = GetNonterminal(ToUtf32("MDLong"));
9750 mDLongNonterminalParser->SetPre(PreMDLong);
9751 mDLongNonterminalParser->SetPost(PostMDLong);
9752 NonterminalParser* mDStringNonterminalParser = GetNonterminal(ToUtf32("MDString"));
9753 mDStringNonterminalParser->SetPre(PreMDString);
9754 mDStringNonterminalParser->SetPost(PostMDString);
9755 NonterminalParser* mDStructRefNonterminalParser = GetNonterminal(ToUtf32("MDStructRef"));
9756 mDStructRefNonterminalParser->SetPre(PreMDStructRef);
9757 mDStructRefNonterminalParser->SetPost(PostMDStructRef);
9758 }
9759 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
9760 {
9761 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9762 context->value = context->fromMDBool;
9763 }
9764 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
9765 {
9766 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9767 context->value = context->fromMDLong;
9768 }
9769 public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
9770 {
9771 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9772 context->value = context->fromMDString;
9773 }
9774 public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
9775 {
9776 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9777 context->value = context->fromMDStructRef;
9778 }
9779 public void PreMDBool(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
9780 {
9781 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9782 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
9783 }
9784 public void PostMDBool(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
9785 {
9786 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9787 if (matched)
9788 {
9789 UniquePtr<Object> fromMDBool_value = stack.Pop();
9790 context->fromMDBool = *cast<ValueObject<MDBool*>*>(fromMDBool_value.Get());
9791 }
9792 }
9793 public void PreMDLong(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
9794 {
9795 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9796 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
9797 }
9798 public void PostMDLong(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
9799 {
9800 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9801 if (matched)
9802 {
9803 UniquePtr<Object> fromMDLong_value = stack.Pop();
9804 context->fromMDLong = *cast<ValueObject<MDLong*>*>(fromMDLong_value.Get());
9805 }
9806 }
9807 public void PreMDString(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
9808 {
9809 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9810 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
9811 }
9812 public void PostMDString(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
9813 {
9814 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9815 if (matched)
9816 {
9817 UniquePtr<Object> fromMDString_value = stack.Pop();
9818 context->fromMDString = *cast<ValueObject<MDString*>*>(fromMDString_value.Get());
9819 }
9820 }
9821 public void PreMDStructRef(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
9822 {
9823 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9824 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
9825 }
9826 public void PostMDStructRef(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
9827 {
9828 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9829 if (matched)
9830 {
9831 UniquePtr<Object> fromMDStructRef_value = stack.Pop();
9832 context->fromMDStructRef = *cast<ValueObject<MDStructRef*>*>(fromMDStructRef_value.Get());
9833 }
9834 }
9835 public class Context : System.Text.Parsing.Context
9836 {
9837 public Context() : context(), value(), fromMDBool(), fromMDLong(), fromMDString(), fromMDStructRef()
9838 {
9839 }
9840 public cmsx.intermediate.Context* context;
9841 public MDItem* value;
9842 public MDBool* fromMDBool;
9843 public MDLong* fromMDLong;
9844 public MDString* fromMDString;
9845 public MDStructRef* fromMDStructRef;
9846 }
9847 }
9848
9849 public class MDBoolRule : System.Text.Parsing.RuleParser
9850 {
9851 public MDBoolRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
9852 {
9853 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
9854 SetValueTypeName(ToUtf32("MDBool*"));
9855 }
9856 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
9857 {
9858 parsingData->PushContext(Id(), new Context());
9859 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9860 UniquePtr<Object> context_value = stack.Pop();
9861 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
9862 }
9863 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
9864 {
9865 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9866 if (matched)
9867 {
9868 stack.Push(UniquePtr<Object>(new ValueObject<MDBool*>(context->value)));
9869 }
9870 parsingData->PopContext(Id());
9871 }
9872 public override void Link()
9873 {
9874 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
9875 a0ActionParser->SetAction(A0Action);
9876 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
9877 a1ActionParser->SetAction(A1Action);
9878 }
9879 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
9880 {
9881 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9882 context->value = context->context->CreateMDBool(true);
9883 }
9884 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
9885 {
9886 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9887 context->value = context->context->CreateMDBool(false);
9888 }
9889 public class Context : System.Text.Parsing.Context
9890 {
9891 public Context() : context(), value()
9892 {
9893 }
9894 public cmsx.intermediate.Context* context;
9895 public MDBool* value;
9896 }
9897 }
9898
9899 public class MDLongRule : System.Text.Parsing.RuleParser
9900 {
9901 public MDLongRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
9902 {
9903 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
9904 SetValueTypeName(ToUtf32("MDLong*"));
9905 }
9906 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
9907 {
9908 parsingData->PushContext(Id(), new Context());
9909 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9910 UniquePtr<Object> context_value = stack.Pop();
9911 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
9912 }
9913 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
9914 {
9915 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9916 if (matched)
9917 {
9918 stack.Push(UniquePtr<Object>(new ValueObject<MDLong*>(context->value)));
9919 }
9920 parsingData->PopContext(Id());
9921 }
9922 public override void Link()
9923 {
9924 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
9925 a0ActionParser->SetAction(A0Action);
9926 NonterminalParser* xNonterminalParser = GetNonterminal(ToUtf32("x"));
9927 xNonterminalParser->SetPost(Postx);
9928 }
9929 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
9930 {
9931 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9932 context->value = context->context->CreateMDLong(context->fromx);
9933 }
9934 public void Postx(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
9935 {
9936 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9937 if (matched)
9938 {
9939 UniquePtr<Object> fromx_value = stack.Pop();
9940 context->fromx = *cast<ValueObject<long>*>(fromx_value.Get());
9941 }
9942 }
9943 public class Context : System.Text.Parsing.Context
9944 {
9945 public Context() : context(), value(), fromx()
9946 {
9947 }
9948 public cmsx.intermediate.Context* context;
9949 public MDLong* value;
9950 public long fromx;
9951 }
9952 }
9953
9954 public class MDStringRule : System.Text.Parsing.RuleParser
9955 {
9956 public MDStringRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
9957 {
9958 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
9959 SetValueTypeName(ToUtf32("MDString*"));
9960 }
9961 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
9962 {
9963 parsingData->PushContext(Id(), new Context());
9964 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9965 UniquePtr<Object> context_value = stack.Pop();
9966 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
9967 }
9968 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
9969 {
9970 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9971 if (matched)
9972 {
9973 stack.Push(UniquePtr<Object>(new ValueObject<MDString*>(context->value)));
9974 }
9975 parsingData->PopContext(Id());
9976 }
9977 public override void Link()
9978 {
9979 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
9980 a0ActionParser->SetAction(A0Action);
9981 NonterminalParser* sNonterminalParser = GetNonterminal(ToUtf32("s"));
9982 sNonterminalParser->SetPost(Posts);
9983 }
9984 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
9985 {
9986 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9987 context->value = context->context->CreateMDString(ToUtf8(context->froms));
9988 }
9989 public void Posts(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
9990 {
9991 Context* context = cast<Context*>(parsingData->GetContext(Id()));
9992 if (matched)
9993 {
9994 UniquePtr<Object> froms_value = stack.Pop();
9995 context->froms = *cast<ValueObject<ustring>*>(froms_value.Get());
9996 }
9997 }
9998 public class Context : System.Text.Parsing.Context
9999 {
10000 public Context() : context(), value(), froms()
10001 {
10002 }
10003 public cmsx.intermediate.Context* context;
10004 public MDString* value;
10005 public ustring froms;
10006 }
10007 }
10008
10009 public class MDStructRefRule : System.Text.Parsing.RuleParser
10010 {
10011 public MDStructRefRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
10012 {
10013 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
10014 SetValueTypeName(ToUtf32("MDStructRef*"));
10015 }
10016 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
10017 {
10018 parsingData->PushContext(Id(), new Context());
10019 Context* context = cast<Context*>(parsingData->GetContext(Id()));
10020 UniquePtr<Object> context_value = stack.Pop();
10021 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
10022 }
10023 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
10024 {
10025 Context* context = cast<Context*>(parsingData->GetContext(Id()));
10026 if (matched)
10027 {
10028 stack.Push(UniquePtr<Object>(new ValueObject<MDStructRef*>(context->value)));
10029 }
10030 parsingData->PopContext(Id());
10031 }
10032 public override void Link()
10033 {
10034 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
10035 a0ActionParser->SetAction(A0Action);
10036 NonterminalParser* idNonterminalParser = GetNonterminal(ToUtf32("id"));
10037 idNonterminalParser->SetPost(Postid);
10038 }
10039 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
10040 {
10041 Context* context = cast<Context*>(parsingData->GetContext(Id()));
10042 context->value = context->context->CreateMDStructRef(context->fromid);
10043 }
10044 public void Postid(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
10045 {
10046 Context* context = cast<Context*>(parsingData->GetContext(Id()));
10047 if (matched)
10048 {
10049 UniquePtr<Object> fromid_value = stack.Pop();
10050 context->fromid = *cast<ValueObject<int>*>(fromid_value.Get());
10051 }
10052 }
10053 public class Context : System.Text.Parsing.Context
10054 {
10055 public Context() : context(), value(), fromid()
10056 {
10057 }
10058 public cmsx.intermediate.Context* context;
10059 public MDStructRef* value;
10060 public int fromid;
10061 }
10062 }
10063
10064 public class MDStructRule : System.Text.Parsing.RuleParser
10065 {
10066 public MDStructRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
10067 {
10068 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
10069 SetValueTypeName(ToUtf32("MDStruct*"));
10070 }
10071 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
10072 {
10073 parsingData->PushContext(Id(), new Context());
10074 Context* context = cast<Context*>(parsingData->GetContext(Id()));
10075 UniquePtr<Object> context_value = stack.Pop();
10076 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
10077 }
10078 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
10079 {
10080 Context* context = cast<Context*>(parsingData->GetContext(Id()));
10081 if (matched)
10082 {
10083 stack.Push(UniquePtr<Object>(new ValueObject<MDStruct*>(context->value)));
10084 }
10085 parsingData->PopContext(Id());
10086 }
10087 public override void Link()
10088 {
10089 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
10090 a0ActionParser->SetAction(A0Action);
10091 NonterminalParser* idNonterminalParser = GetNonterminal(ToUtf32("id"));
10092 idNonterminalParser->SetPost(Postid);
10093 NonterminalParser* fieldNonterminalParser = GetNonterminal(ToUtf32("field"));
10094 fieldNonterminalParser->SetPre(Prefield);
10095 }
10096 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
10097 {
10098 Context* context = cast<Context*>(parsingData->GetContext(Id()));
10099 context->value = context->context->CreateMDStruct(context->fromid);
10100 }
10101 public void Postid(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
10102 {
10103 Context* context = cast<Context*>(parsingData->GetContext(Id()));
10104 if (matched)
10105 {
10106 UniquePtr<Object> fromid_value = stack.Pop();
10107 context->fromid = *cast<ValueObject<int>*>(fromid_value.Get());
10108 }
10109 }
10110 public void Prefield(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
10111 {
10112 Context* context = cast<Context*>(parsingData->GetContext(Id()));
10113 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
10114 stack.Push(UniquePtr<Object>(new ValueObject<MDStruct*>(context->value)));
10115 }
10116 public class Context : System.Text.Parsing.Context
10117 {
10118 public Context() : context(), value(), fromid()
10119 {
10120 }
10121 public cmsx.intermediate.Context* context;
10122 public MDStruct* value;
10123 public int fromid;
10124 }
10125 }
10126
10127 public class MDFieldRule : System.Text.Parsing.RuleParser
10128 {
10129 public MDFieldRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
10130 {
10131 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
10132 AddInheritedAttribute(AttrOrVar(ToUtf32("MDStruct*"), ToUtf32("parent")));
10133 }
10134 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
10135 {
10136 parsingData->PushContext(Id(), new Context());
10137 Context* context = cast<Context*>(parsingData->GetContext(Id()));
10138 UniquePtr<Object> parent_value = stack.Pop();
10139 context->parent = *cast<ValueObject<MDStruct*>*>(parent_value.Get());
10140 UniquePtr<Object> context_value = stack.Pop();
10141 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
10142 }
10143 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
10144 {
10145 parsingData->PopContext(Id());
10146 }
10147 public override void Link()
10148 {
10149 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
10150 a0ActionParser->SetAction(A0Action);
10151 NonterminalParser* fieldNameNonterminalParser = GetNonterminal(ToUtf32("fieldName"));
10152 fieldNameNonterminalParser->SetPost(PostfieldName);
10153 NonterminalParser* itemNonterminalParser = GetNonterminal(ToUtf32("item"));
10154 itemNonterminalParser->SetPre(Preitem);
10155 itemNonterminalParser->SetPost(Postitem);
10156 }
10157 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
10158 {
10159 Context* context = cast<Context*>(parsingData->GetContext(Id()));
10160 context->parent->AddItem(ToUtf8(context->fromfieldName), context->fromitem);
10161 }
10162 public void PostfieldName(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
10163 {
10164 Context* context = cast<Context*>(parsingData->GetContext(Id()));
10165 if (matched)
10166 {
10167 UniquePtr<Object> fromfieldName_value = stack.Pop();
10168 context->fromfieldName = *cast<ValueObject<ustring>*>(fromfieldName_value.Get());
10169 }
10170 }
10171 public void Preitem(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
10172 {
10173 Context* context = cast<Context*>(parsingData->GetContext(Id()));
10174 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
10175 }
10176 public void Postitem(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
10177 {
10178 Context* context = cast<Context*>(parsingData->GetContext(Id()));
10179 if (matched)
10180 {
10181 UniquePtr<Object> fromitem_value = stack.Pop();
10182 context->fromitem = *cast<ValueObject<MDItem*>*>(fromitem_value.Get());
10183 }
10184 }
10185 public class Context : System.Text.Parsing.Context
10186 {
10187 public Context() : context(), parent(), fromfieldName(), fromitem()
10188 {
10189 }
10190 public cmsx.intermediate.Context* context;
10191 public MDStruct* parent;
10192 public ustring fromfieldName;
10193 public MDItem* fromitem;
10194 }
10195 }
10196
10197 public override void GetReferencedGrammars()
10198 {
10199 ParsingDomain* pd = Domain();
10200 Grammar* grammar0 = pd->GetGrammar(ToUtf32("System.Text.Parsing.stdlib"));
10201 if (grammar0 == null)
10202 {
10203 grammar0 = new System.Text.Parsing.stdlib(pd);
10204 }
10205 AddGrammarReference(grammar0);
10206 }
10207 public override void CreateRules()
10208 {
10209 AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("identifier"), this, ToUtf32("System.Text.Parsing.stdlib.identifier")));
10210 AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("newline"), this, ToUtf32("System.Text.Parsing.stdlib.newline")));
10211 AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("bool"), this, ToUtf32("System.Text.Parsing.stdlib.bool")));
10212 AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("sbyte"), this, ToUtf32("System.Text.Parsing.stdlib.sbyte")));
10213 AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("byte"), this, ToUtf32("System.Text.Parsing.stdlib.byte")));
10214 AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("short"), this, ToUtf32("System.Text.Parsing.stdlib.short")));
10215 AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("ushort"), this, ToUtf32("System.Text.Parsing.stdlib.ushort")));
10216 AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("int"), this, ToUtf32("System.Text.Parsing.stdlib.int")));
10217 AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("uint"), this, ToUtf32("System.Text.Parsing.stdlib.uint")));
10218 AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("long"), this, ToUtf32("System.Text.Parsing.stdlib.long")));
10219 AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("ulong"), this, ToUtf32("System.Text.Parsing.stdlib.ulong")));
10220 AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("float"), this, ToUtf32("System.Text.Parsing.stdlib.float")));
10221 AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("double"), this, ToUtf32("System.Text.Parsing.stdlib.double")));
10222 AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("string"), this, ToUtf32("System.Text.Parsing.stdlib.string")));
10223 AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("spaces"), this, ToUtf32("System.Text.Parsing.stdlib.spaces")));
10224 AddRule(new IntermediateCodeFileRule(ToUtf32("IntermediateCodeFile"), GetScope(), Domain()->GetNextRuleId(),
10225 new System.Text.Parsing.SequenceParser(
10226 new System.Text.Parsing.SequenceParser(
10227 new System.Text.Parsing.SequenceParser(
10228 new System.Text.Parsing.SequenceParser(
10229 new System.Text.Parsing.SequenceParser(
10230 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
10231 new System.Text.Parsing.EmptyParser()),
10232 new System.Text.Parsing.NonterminalParser(ToUtf32("CompileUnitHeader"), ToUtf32("CompileUnitHeader"), 1)),
10233 new System.Text.Parsing.OptionalParser(
10234 new System.Text.Parsing.NonterminalParser(ToUtf32("TypeDeclarations"), ToUtf32("TypeDeclarations"), 1))),
10235 new System.Text.Parsing.OptionalParser(
10236 new System.Text.Parsing.NonterminalParser(ToUtf32("DataDefinitions"), ToUtf32("DataDefinitions"), 1))),
10237 new System.Text.Parsing.OptionalParser(
10238 new System.Text.Parsing.NonterminalParser(ToUtf32("Functions"), ToUtf32("Functions"), 1))),
10239 new System.Text.Parsing.OptionalParser(
10240 new System.Text.Parsing.NonterminalParser(ToUtf32("Metadata"), ToUtf32("Metadata"), 1)))));
10241 AddRule(new CompileUnitHeaderRule(ToUtf32("CompileUnitHeader"), GetScope(), Domain()->GetNextRuleId(),
10242 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
10243 new System.Text.Parsing.GroupingParser(
10244 new System.Text.Parsing.SequenceParser(
10245 new System.Text.Parsing.SequenceParser(
10246 new System.Text.Parsing.SequenceParser(
10247 new System.Text.Parsing.SequenceParser(
10248 new System.Text.Parsing.SequenceParser(
10249 new System.Text.Parsing.KeywordParser(ToUtf32("cu")),
10250 new System.Text.Parsing.CharParser('(')),
10251 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
10252 new System.Text.Parsing.GroupingParser(
10253 new System.Text.Parsing.PositiveParser(
10254 new System.Text.Parsing.HexDigitParser())))),
10255 new System.Text.Parsing.CharParser(',')),
10256 new System.Text.Parsing.ActionParser(ToUtf32("A2"),
10257 new System.Text.Parsing.NonterminalParser(ToUtf32("MDStructRef"), ToUtf32("MDStructRef"), 1))),
10258 new System.Text.Parsing.CharParser(')'))))));
10259 AddRule(new TypeDeclarationsRule(ToUtf32("TypeDeclarations"), GetScope(), Domain()->GetNextRuleId(),
10260 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
10261 new System.Text.Parsing.GroupingParser(
10262 new System.Text.Parsing.SequenceParser(
10263 new System.Text.Parsing.SequenceParser(
10264 new System.Text.Parsing.SequenceParser(
10265 new System.Text.Parsing.KeywordParser(ToUtf32("types")),
10266 new System.Text.Parsing.ExpectationParser(
10267 new System.Text.Parsing.CharParser('{'))),
10268 new System.Text.Parsing.KleeneStarParser(
10269 new System.Text.Parsing.NonterminalParser(ToUtf32("TypeDeclaration"), ToUtf32("TypeDeclaration"), 1))),
10270 new System.Text.Parsing.ExpectationParser(
10271 new System.Text.Parsing.CharParser('}')))))));
10272 AddRule(new DataDefinitionsRule(ToUtf32("DataDefinitions"), GetScope(), Domain()->GetNextRuleId(),
10273 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
10274 new System.Text.Parsing.GroupingParser(
10275 new System.Text.Parsing.SequenceParser(
10276 new System.Text.Parsing.SequenceParser(
10277 new System.Text.Parsing.SequenceParser(
10278 new System.Text.Parsing.KeywordParser(ToUtf32("data")),
10279 new System.Text.Parsing.ExpectationParser(
10280 new System.Text.Parsing.CharParser('{'))),
10281 new System.Text.Parsing.KleeneStarParser(
10282 new System.Text.Parsing.NonterminalParser(ToUtf32("DataDefinition"), ToUtf32("DataDefinition"), 1))),
10283 new System.Text.Parsing.ExpectationParser(
10284 new System.Text.Parsing.CharParser('}')))))));
10285 AddRule(new FunctionsRule(ToUtf32("Functions"), GetScope(), Domain()->GetNextRuleId(),
10286 new System.Text.Parsing.KleeneStarParser(
10287 new System.Text.Parsing.NonterminalParser(ToUtf32("Function"), ToUtf32("Function"), 1))));
10288 AddRule(new FunctionRule(ToUtf32("Function"), GetScope(), Domain()->GetNextRuleId(),
10289 new System.Text.Parsing.SequenceParser(
10290 new System.Text.Parsing.SequenceParser(
10291 new System.Text.Parsing.SequenceParser(
10292 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
10293 new System.Text.Parsing.NonterminalParser(ToUtf32("function"), ToUtf32("FunctionHeader"), 1)),
10294 new System.Text.Parsing.ExpectationParser(
10295 new System.Text.Parsing.CharParser('{'))),
10296 new System.Text.Parsing.KleeneStarParser(
10297 new System.Text.Parsing.NonterminalParser(ToUtf32("BasicBlock"), ToUtf32("BasicBlock"), 2))),
10298 new System.Text.Parsing.ExpectationParser(
10299 new System.Text.Parsing.CharParser('}')))));
10300 AddRule(new FunctionHeaderRule(ToUtf32("FunctionHeader"), GetScope(), Domain()->GetNextRuleId(),
10301 new System.Text.Parsing.SequenceParser(
10302 new System.Text.Parsing.SequenceParser(
10303 new System.Text.Parsing.SequenceParser(
10304 new System.Text.Parsing.SequenceParser(
10305 new System.Text.Parsing.KeywordParser(ToUtf32("function")),
10306 new System.Text.Parsing.ExpectationParser(
10307 new System.Text.Parsing.NonterminalParser(ToUtf32("functionType"), ToUtf32("TypeExpr"), 1))),
10308 new System.Text.Parsing.OptionalParser(
10309 new System.Text.Parsing.GroupingParser(
10310 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
10311 new System.Text.Parsing.KeywordParser(ToUtf32("once")))))),
10312 new System.Text.Parsing.ExpectationParser(
10313 new System.Text.Parsing.NonterminalParser(ToUtf32("functionId"), ToUtf32("identifier"), 0))),
10314 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
10315 new System.Text.Parsing.GroupingParser(
10316 new System.Text.Parsing.OptionalParser(
10317 new System.Text.Parsing.NonterminalParser(ToUtf32("md"), ToUtf32("MDStructRef"), 1)))))));
10318 AddRule(new BasicBlockRule(ToUtf32("BasicBlock"), GetScope(), Domain()->GetNextRuleId(),
10319 new System.Text.Parsing.TokenParser(
10320 new System.Text.Parsing.SequenceParser(
10321 new System.Text.Parsing.SequenceParser(
10322 new System.Text.Parsing.SequenceParser(
10323 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
10324 new System.Text.Parsing.NonterminalParser(ToUtf32("id"), ToUtf32("Label"), 0)),
10325 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
10326 new System.Text.Parsing.PositiveParser(
10327 new System.Text.Parsing.NonterminalParser(ToUtf32("InstructionLine"), ToUtf32("InstructionLine"), 2))),
10328 new System.Text.Parsing.OptionalParser(
10329 new System.Text.Parsing.NonterminalParser(ToUtf32("EmptyLine"), ToUtf32("EmptyLine"), 0))))));
10330 AddRule(new System.Text.Parsing.RuleParser(ToUtf32("EmptyLine"), GetScope(), Domain()->GetNextRuleId(),
10331 new System.Text.Parsing.TokenParser(
10332 new System.Text.Parsing.SequenceParser(
10333 new System.Text.Parsing.OptionalParser(
10334 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
10335 new System.Text.Parsing.NonterminalParser(ToUtf32("newline"), ToUtf32("newline"), 0)))));
10336 AddRule(new InstructionLineRule(ToUtf32("InstructionLine"), GetScope(), Domain()->GetNextRuleId(),
10337 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
10338 new System.Text.Parsing.TokenParser(
10339 new System.Text.Parsing.SequenceParser(
10340 new System.Text.Parsing.SequenceParser(
10341 new System.Text.Parsing.SequenceParser(
10342 new System.Text.Parsing.SequenceParser(
10343 new System.Text.Parsing.OptionalParser(
10344 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
10345 new System.Text.Parsing.NonterminalParser(ToUtf32("Instruction"), ToUtf32("Instruction"), 1)),
10346 new System.Text.Parsing.OptionalParser(
10347 new System.Text.Parsing.GroupingParser(
10348 new System.Text.Parsing.SequenceParser(
10349 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0),
10350 new System.Text.Parsing.NonterminalParser(ToUtf32("lineInfo"), ToUtf32("MDStructRef"), 1))))),
10351 new System.Text.Parsing.OptionalParser(
10352 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0))),
10353 new System.Text.Parsing.ExpectationParser(
10354 new System.Text.Parsing.NonterminalParser(ToUtf32("newline"), ToUtf32("newline"), 0)))))));
10355 AddRule(new InstructionRule(ToUtf32("Instruction"), GetScope(), Domain()->GetNextRuleId(),
10356 new System.Text.Parsing.AlternativeParser(
10357 new System.Text.Parsing.AlternativeParser(
10358 new System.Text.Parsing.AlternativeParser(
10359 new System.Text.Parsing.AlternativeParser(
10360 new System.Text.Parsing.AlternativeParser(
10361 new System.Text.Parsing.AlternativeParser(
10362 new System.Text.Parsing.AlternativeParser(
10363 new System.Text.Parsing.AlternativeParser(
10364 new System.Text.Parsing.AlternativeParser(
10365 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
10366 new System.Text.Parsing.NonterminalParser(ToUtf32("StoreInstruction"), ToUtf32("StoreInstruction"), 1)),
10367 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
10368 new System.Text.Parsing.NonterminalParser(ToUtf32("ArgInstruction"), ToUtf32("ArgInstruction"), 1))),
10369 new System.Text.Parsing.ActionParser(ToUtf32("A2"),
10370 new System.Text.Parsing.NonterminalParser(ToUtf32("JumpInstruction"), ToUtf32("JumpInstruction"), 1))),
10371 new System.Text.Parsing.ActionParser(ToUtf32("A3"),
10372 new System.Text.Parsing.NonterminalParser(ToUtf32("BranchInstruction"), ToUtf32("BranchInstruction"), 1))),
10373 new System.Text.Parsing.ActionParser(ToUtf32("A4"),
10374 new System.Text.Parsing.NonterminalParser(ToUtf32("ProcedureCallInstruction"), ToUtf32("ProcedureCallInstruction"), 1))),
10375 new System.Text.Parsing.ActionParser(ToUtf32("A5"),
10376 new System.Text.Parsing.NonterminalParser(ToUtf32("RetInstruction"), ToUtf32("RetInstruction"), 1))),
10377 new System.Text.Parsing.ActionParser(ToUtf32("A6"),
10378 new System.Text.Parsing.NonterminalParser(ToUtf32("SwitchInstruction"), ToUtf32("SwitchInstruction"), 1))),
10379 new System.Text.Parsing.ActionParser(ToUtf32("A7"),
10380 new System.Text.Parsing.NonterminalParser(ToUtf32("ValueInstruction"), ToUtf32("ValueInstruction"), 1))),
10381 new System.Text.Parsing.ActionParser(ToUtf32("A8"),
10382 new System.Text.Parsing.NonterminalParser(ToUtf32("NoOperationInstruction"), ToUtf32("NoOperationInstruction"), 1))),
10383 new System.Text.Parsing.ActionParser(ToUtf32("A9"),
10384 new System.Text.Parsing.NonterminalParser(ToUtf32("SaveInstruction"), ToUtf32("SaveInstruction"), 1)))));
10385 AddRule(new StoreInstructionRule(ToUtf32("StoreInstruction"), GetScope(), Domain()->GetNextRuleId(),
10386 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
10387 new System.Text.Parsing.GroupingParser(
10388 new System.Text.Parsing.SequenceParser(
10389 new System.Text.Parsing.SequenceParser(
10390 new System.Text.Parsing.SequenceParser(
10391 new System.Text.Parsing.SequenceParser(
10392 new System.Text.Parsing.SequenceParser(
10393 new System.Text.Parsing.SequenceParser(
10394 new System.Text.Parsing.SequenceParser(
10395 new System.Text.Parsing.SequenceParser(
10396 new System.Text.Parsing.KeywordParser(ToUtf32("store")),
10397 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
10398 new System.Text.Parsing.ExpectationParser(
10399 new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("TypeExpr"), 1))),
10400 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
10401 new System.Text.Parsing.ExpectationParser(
10402 new System.Text.Parsing.NonterminalParser(ToUtf32("val"), ToUtf32("Value"), 2))),
10403 new System.Text.Parsing.ExpectationParser(
10404 new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))),
10405 new System.Text.Parsing.ExpectationParser(
10406 new System.Text.Parsing.NonterminalParser(ToUtf32("ptrType"), ToUtf32("TypeExpr"), 1))),
10407 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
10408 new System.Text.Parsing.ExpectationParser(
10409 new System.Text.Parsing.NonterminalParser(ToUtf32("ptr"), ToUtf32("Value"), 2)))))));
10410 AddRule(new ArgInstructionRule(ToUtf32("ArgInstruction"), GetScope(), Domain()->GetNextRuleId(),
10411 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
10412 new System.Text.Parsing.GroupingParser(
10413 new System.Text.Parsing.SequenceParser(
10414 new System.Text.Parsing.SequenceParser(
10415 new System.Text.Parsing.SequenceParser(
10416 new System.Text.Parsing.SequenceParser(
10417 new System.Text.Parsing.KeywordParser(ToUtf32("arg")),
10418 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
10419 new System.Text.Parsing.ExpectationParser(
10420 new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("TypeExpr"), 1))),
10421 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
10422 new System.Text.Parsing.ExpectationParser(
10423 new System.Text.Parsing.NonterminalParser(ToUtf32("arg"), ToUtf32("Value"), 2)))))));
10424 AddRule(new JumpInstructionRule(ToUtf32("JumpInstruction"), GetScope(), Domain()->GetNextRuleId(),
10425 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
10426 new System.Text.Parsing.GroupingParser(
10427 new System.Text.Parsing.SequenceParser(
10428 new System.Text.Parsing.SequenceParser(
10429 new System.Text.Parsing.KeywordParser(ToUtf32("jmp")),
10430 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
10431 new System.Text.Parsing.ExpectationParser(
10432 new System.Text.Parsing.NonterminalParser(ToUtf32("target"), ToUtf32("Label"), 0)))))));
10433 AddRule(new BranchInstructionRule(ToUtf32("BranchInstruction"), GetScope(), Domain()->GetNextRuleId(),
10434 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
10435 new System.Text.Parsing.GroupingParser(
10436 new System.Text.Parsing.SequenceParser(
10437 new System.Text.Parsing.SequenceParser(
10438 new System.Text.Parsing.SequenceParser(
10439 new System.Text.Parsing.SequenceParser(
10440 new System.Text.Parsing.SequenceParser(
10441 new System.Text.Parsing.SequenceParser(
10442 new System.Text.Parsing.SequenceParser(
10443 new System.Text.Parsing.SequenceParser(
10444 new System.Text.Parsing.KeywordParser(ToUtf32("branch")),
10445 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
10446 new System.Text.Parsing.ExpectationParser(
10447 new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("TypeExpr"), 1))),
10448 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
10449 new System.Text.Parsing.ExpectationParser(
10450 new System.Text.Parsing.NonterminalParser(ToUtf32("cond"), ToUtf32("Value"), 2))),
10451 new System.Text.Parsing.ExpectationParser(
10452 new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))),
10453 new System.Text.Parsing.ExpectationParser(
10454 new System.Text.Parsing.NonterminalParser(ToUtf32("trueTarget"), ToUtf32("Label"), 0))),
10455 new System.Text.Parsing.ExpectationParser(
10456 new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))),
10457 new System.Text.Parsing.ExpectationParser(
10458 new System.Text.Parsing.NonterminalParser(ToUtf32("falseTarget"), ToUtf32("Label"), 0)))))));
10459 AddRule(new ProcedureCallInstructionRule(ToUtf32("ProcedureCallInstruction"), GetScope(), Domain()->GetNextRuleId(),
10460 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
10461 new System.Text.Parsing.GroupingParser(
10462 new System.Text.Parsing.SequenceParser(
10463 new System.Text.Parsing.SequenceParser(
10464 new System.Text.Parsing.SequenceParser(
10465 new System.Text.Parsing.SequenceParser(
10466 new System.Text.Parsing.KeywordParser(ToUtf32("call")),
10467 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
10468 new System.Text.Parsing.ExpectationParser(
10469 new System.Text.Parsing.NonterminalParser(ToUtf32("functionType"), ToUtf32("TypeExpr"), 1))),
10470 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
10471 new System.Text.Parsing.ExpectationParser(
10472 new System.Text.Parsing.NonterminalParser(ToUtf32("callee"), ToUtf32("Value"), 2)))))));
10473 AddRule(new RetInstructionRule(ToUtf32("RetInstruction"), GetScope(), Domain()->GetNextRuleId(),
10474 new System.Text.Parsing.SequenceParser(
10475 new System.Text.Parsing.SequenceParser(
10476 new System.Text.Parsing.KeywordParser(ToUtf32("ret")),
10477 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
10478 new System.Text.Parsing.GroupingParser(
10479 new System.Text.Parsing.AlternativeParser(
10480 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
10481 new System.Text.Parsing.GroupingParser(
10482 new System.Text.Parsing.DifferenceParser(
10483 new System.Text.Parsing.KeywordParser(ToUtf32("void")),
10484 new System.Text.Parsing.StringParser(ToUtf32("void*"))))),
10485 new System.Text.Parsing.SequenceParser(
10486 new System.Text.Parsing.SequenceParser(
10487 new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("TypeExpr"), 1),
10488 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
10489 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
10490 new System.Text.Parsing.NonterminalParser(ToUtf32("val"), ToUtf32("Value"), 2))))))));
10491 AddRule(new SwitchInstructionRule(ToUtf32("SwitchInstruction"), GetScope(), Domain()->GetNextRuleId(),
10492 new System.Text.Parsing.SequenceParser(
10493 new System.Text.Parsing.SequenceParser(
10494 new System.Text.Parsing.SequenceParser(
10495 new System.Text.Parsing.SequenceParser(
10496 new System.Text.Parsing.SequenceParser(
10497 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
10498 new System.Text.Parsing.GroupingParser(
10499 new System.Text.Parsing.SequenceParser(
10500 new System.Text.Parsing.SequenceParser(
10501 new System.Text.Parsing.SequenceParser(
10502 new System.Text.Parsing.SequenceParser(
10503 new System.Text.Parsing.SequenceParser(
10504 new System.Text.Parsing.SequenceParser(
10505 new System.Text.Parsing.KeywordParser(ToUtf32("switch")),
10506 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
10507 new System.Text.Parsing.ExpectationParser(
10508 new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("TypeExpr"), 1))),
10509 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
10510 new System.Text.Parsing.ExpectationParser(
10511 new System.Text.Parsing.NonterminalParser(ToUtf32("cond"), ToUtf32("Value"), 2))),
10512 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
10513 new System.Text.Parsing.ExpectationParser(
10514 new System.Text.Parsing.NonterminalParser(ToUtf32("defaultTarget"), ToUtf32("Label"), 0))))),
10515 new System.Text.Parsing.ExpectationParser(
10516 new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))),
10517 new System.Text.Parsing.ExpectationParser(
10518 new System.Text.Parsing.CharParser('['))),
10519 new System.Text.Parsing.OptionalParser(
10520 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0))),
10521 new System.Text.Parsing.ListParser(
10522 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
10523 new System.Text.Parsing.GroupingParser(
10524 new System.Text.Parsing.SequenceParser(
10525 new System.Text.Parsing.SequenceParser(
10526 new System.Text.Parsing.SequenceParser(
10527 new System.Text.Parsing.SequenceParser(
10528 new System.Text.Parsing.NonterminalParser(ToUtf32("caseType"), ToUtf32("TypeExpr"), 1),
10529 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
10530 new System.Text.Parsing.NonterminalParser(ToUtf32("caseValue"), ToUtf32("Value"), 2)),
10531 new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0)),
10532 new System.Text.Parsing.NonterminalParser(ToUtf32("caseTarget"), ToUtf32("Label"), 0)))),
10533 new System.Text.Parsing.GroupingParser(
10534 new System.Text.Parsing.SequenceParser(
10535 new System.Text.Parsing.SequenceParser(
10536 new System.Text.Parsing.OptionalParser(
10537 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
10538 new System.Text.Parsing.CharParser(':')),
10539 new System.Text.Parsing.OptionalParser(
10540 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)))))),
10541 new System.Text.Parsing.ExpectationParser(
10542 new System.Text.Parsing.CharParser(']')))));
10543 AddRule(new NoOperationInstructionRule(ToUtf32("NoOperationInstruction"), GetScope(), Domain()->GetNextRuleId(),
10544 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
10545 new System.Text.Parsing.KeywordParser(ToUtf32("nop")))));
10546 AddRule(new SaveInstructionRule(ToUtf32("SaveInstruction"), GetScope(), Domain()->GetNextRuleId(),
10547 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
10548 new System.Text.Parsing.KeywordParser(ToUtf32("save")))));
10549 AddRule(new ValueInstructionRule(ToUtf32("ValueInstruction"), GetScope(), Domain()->GetNextRuleId(),
10550 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
10551 new System.Text.Parsing.GroupingParser(
10552 new System.Text.Parsing.SequenceParser(
10553 new System.Text.Parsing.SequenceParser(
10554 new System.Text.Parsing.SequenceParser(
10555 new System.Text.Parsing.SequenceParser(
10556 new System.Text.Parsing.SequenceParser(
10557 new System.Text.Parsing.SequenceParser(
10558 new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("TypeExpr"), 1),
10559 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
10560 new System.Text.Parsing.ExpectationParser(
10561 new System.Text.Parsing.NonterminalParser(ToUtf32("result"), ToUtf32("Value"), 2))),
10562 new System.Text.Parsing.OptionalParser(
10563 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0))),
10564 new System.Text.Parsing.CharParser('=')),
10565 new System.Text.Parsing.OptionalParser(
10566 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0))),
10567 new System.Text.Parsing.ExpectationParser(
10568 new System.Text.Parsing.NonterminalParser(ToUtf32("Operation"), ToUtf32("Operation"), 2)))))));
10569 AddRule(new OperationRule(ToUtf32("Operation"), GetScope(), Domain()->GetNextRuleId(),
10570 new System.Text.Parsing.AlternativeParser(
10571 new System.Text.Parsing.AlternativeParser(
10572 new System.Text.Parsing.AlternativeParser(
10573 new System.Text.Parsing.AlternativeParser(
10574 new System.Text.Parsing.AlternativeParser(
10575 new System.Text.Parsing.AlternativeParser(
10576 new System.Text.Parsing.AlternativeParser(
10577 new System.Text.Parsing.AlternativeParser(
10578 new System.Text.Parsing.AlternativeParser(
10579 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
10580 new System.Text.Parsing.NonterminalParser(ToUtf32("UnaryInstruction"), ToUtf32("UnaryInstruction"), 2)),
10581 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
10582 new System.Text.Parsing.NonterminalParser(ToUtf32("BinaryInstruction"), ToUtf32("BinaryInstruction"), 2))),
10583 new System.Text.Parsing.ActionParser(ToUtf32("A2"),
10584 new System.Text.Parsing.NonterminalParser(ToUtf32("ParamInstruction"), ToUtf32("ParamInstruction"), 2))),
10585 new System.Text.Parsing.ActionParser(ToUtf32("A3"),
10586 new System.Text.Parsing.NonterminalParser(ToUtf32("LocalInstruction"), ToUtf32("LocalInstruction"), 2))),
10587 new System.Text.Parsing.ActionParser(ToUtf32("A4"),
10588 new System.Text.Parsing.NonterminalParser(ToUtf32("LoadInstruction"), ToUtf32("LoadInstruction"), 2))),
10589 new System.Text.Parsing.ActionParser(ToUtf32("A5"),
10590 new System.Text.Parsing.NonterminalParser(ToUtf32("ElemAddrInstruction"), ToUtf32("ElemAddrInstruction"), 2))),
10591 new System.Text.Parsing.ActionParser(ToUtf32("A6"),
10592 new System.Text.Parsing.NonterminalParser(ToUtf32("PtrOffsetInstruction"), ToUtf32("PtrOffsetInstruction"), 2))),
10593 new System.Text.Parsing.ActionParser(ToUtf32("A7"),
10594 new System.Text.Parsing.NonterminalParser(ToUtf32("PtrDiffInstruction"), ToUtf32("PtrDiffInstruction"), 2))),
10595 new System.Text.Parsing.ActionParser(ToUtf32("A8"),
10596 new System.Text.Parsing.NonterminalParser(ToUtf32("FunctionCallInstruction"), ToUtf32("FunctionCallInstruction"), 2))),
10597 new System.Text.Parsing.ActionParser(ToUtf32("A9"),
10598 new System.Text.Parsing.NonterminalParser(ToUtf32("TrapInstruction"), ToUtf32("TrapInstruction"), 2)))));
10599 AddRule(new UnaryInstructionRule(ToUtf32("UnaryInstruction"), GetScope(), Domain()->GetNextRuleId(),
10600 new System.Text.Parsing.AlternativeParser(
10601 new System.Text.Parsing.AlternativeParser(
10602 new System.Text.Parsing.AlternativeParser(
10603 new System.Text.Parsing.AlternativeParser(
10604 new System.Text.Parsing.AlternativeParser(
10605 new System.Text.Parsing.AlternativeParser(
10606 new System.Text.Parsing.AlternativeParser(
10607 new System.Text.Parsing.AlternativeParser(
10608 new System.Text.Parsing.AlternativeParser(
10609 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
10610 new System.Text.Parsing.NonterminalParser(ToUtf32("NotInstruction"), ToUtf32("NotInstruction"), 2)),
10611 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
10612 new System.Text.Parsing.NonterminalParser(ToUtf32("NegInstruction"), ToUtf32("NegInstruction"), 2))),
10613 new System.Text.Parsing.ActionParser(ToUtf32("A2"),
10614 new System.Text.Parsing.NonterminalParser(ToUtf32("SignExtendInstruction"), ToUtf32("SignExtendInstruction"), 2))),
10615 new System.Text.Parsing.ActionParser(ToUtf32("A3"),
10616 new System.Text.Parsing.NonterminalParser(ToUtf32("ZeroExtendInstruction"), ToUtf32("ZeroExtendInstruction"), 2))),
10617 new System.Text.Parsing.ActionParser(ToUtf32("A4"),
10618 new System.Text.Parsing.NonterminalParser(ToUtf32("TruncateInstruction"), ToUtf32("TruncateInstruction"), 2))),
10619 new System.Text.Parsing.ActionParser(ToUtf32("A5"),
10620 new System.Text.Parsing.NonterminalParser(ToUtf32("BitCastInstruction"), ToUtf32("BitCastInstruction"), 2))),
10621 new System.Text.Parsing.ActionParser(ToUtf32("A6"),
10622 new System.Text.Parsing.NonterminalParser(ToUtf32("IntToFloatInstruction"), ToUtf32("IntToFloatInstruction"), 2))),
10623 new System.Text.Parsing.ActionParser(ToUtf32("A7"),
10624 new System.Text.Parsing.NonterminalParser(ToUtf32("FloatToIntInstruction"), ToUtf32("FloatToIntInstruction"), 2))),
10625 new System.Text.Parsing.ActionParser(ToUtf32("A8"),
10626 new System.Text.Parsing.NonterminalParser(ToUtf32("IntToPtrInstruction"), ToUtf32("IntToPtrInstruction"), 2))),
10627 new System.Text.Parsing.ActionParser(ToUtf32("A9"),
10628 new System.Text.Parsing.NonterminalParser(ToUtf32("PtrToIntInstruction"), ToUtf32("PtrToIntInstruction"), 2)))));
10629 AddRule(new NotInstructionRule(ToUtf32("NotInstruction"), GetScope(), Domain()->GetNextRuleId(),
10630 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
10631 new System.Text.Parsing.GroupingParser(
10632 new System.Text.Parsing.SequenceParser(
10633 new System.Text.Parsing.SequenceParser(
10634 new System.Text.Parsing.KeywordParser(ToUtf32("not")),
10635 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
10636 new System.Text.Parsing.ExpectationParser(
10637 new System.Text.Parsing.NonterminalParser(ToUtf32("arg"), ToUtf32("Operand"), 1)))))));
10638 AddRule(new NegInstructionRule(ToUtf32("NegInstruction"), GetScope(), Domain()->GetNextRuleId(),
10639 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
10640 new System.Text.Parsing.GroupingParser(
10641 new System.Text.Parsing.SequenceParser(
10642 new System.Text.Parsing.SequenceParser(
10643 new System.Text.Parsing.KeywordParser(ToUtf32("neg")),
10644 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
10645 new System.Text.Parsing.ExpectationParser(
10646 new System.Text.Parsing.NonterminalParser(ToUtf32("arg"), ToUtf32("Operand"), 1)))))));
10647 AddRule(new SignExtendInstructionRule(ToUtf32("SignExtendInstruction"), GetScope(), Domain()->GetNextRuleId(),
10648 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
10649 new System.Text.Parsing.GroupingParser(
10650 new System.Text.Parsing.SequenceParser(
10651 new System.Text.Parsing.SequenceParser(
10652 new System.Text.Parsing.KeywordParser(ToUtf32("signextend")),
10653 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
10654 new System.Text.Parsing.ExpectationParser(
10655 new System.Text.Parsing.NonterminalParser(ToUtf32("arg"), ToUtf32("Operand"), 1)))))));
10656 AddRule(new ZeroExtendInstructionRule(ToUtf32("ZeroExtendInstruction"), GetScope(), Domain()->GetNextRuleId(),
10657 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
10658 new System.Text.Parsing.GroupingParser(
10659 new System.Text.Parsing.SequenceParser(
10660 new System.Text.Parsing.SequenceParser(
10661 new System.Text.Parsing.KeywordParser(ToUtf32("zeroextend")),
10662 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
10663 new System.Text.Parsing.ExpectationParser(
10664 new System.Text.Parsing.NonterminalParser(ToUtf32("arg"), ToUtf32("Operand"), 1)))))));
10665 AddRule(new TruncateInstructionRule(ToUtf32("TruncateInstruction"), GetScope(), Domain()->GetNextRuleId(),
10666 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
10667 new System.Text.Parsing.GroupingParser(
10668 new System.Text.Parsing.SequenceParser(
10669 new System.Text.Parsing.SequenceParser(
10670 new System.Text.Parsing.KeywordParser(ToUtf32("truncate")),
10671 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
10672 new System.Text.Parsing.ExpectationParser(
10673 new System.Text.Parsing.NonterminalParser(ToUtf32("arg"), ToUtf32("Operand"), 1)))))));
10674 AddRule(new BitCastInstructionRule(ToUtf32("BitCastInstruction"), GetScope(), Domain()->GetNextRuleId(),
10675 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
10676 new System.Text.Parsing.GroupingParser(
10677 new System.Text.Parsing.SequenceParser(
10678 new System.Text.Parsing.SequenceParser(
10679 new System.Text.Parsing.KeywordParser(ToUtf32("bitcast")),
10680 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
10681 new System.Text.Parsing.ExpectationParser(
10682 new System.Text.Parsing.NonterminalParser(ToUtf32("arg"), ToUtf32("Operand"), 1)))))));
10683 AddRule(new IntToFloatInstructionRule(ToUtf32("IntToFloatInstruction"), GetScope(), Domain()->GetNextRuleId(),
10684 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
10685 new System.Text.Parsing.GroupingParser(
10686 new System.Text.Parsing.SequenceParser(
10687 new System.Text.Parsing.SequenceParser(
10688 new System.Text.Parsing.KeywordParser(ToUtf32("inttofloat")),
10689 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
10690 new System.Text.Parsing.ExpectationParser(
10691 new System.Text.Parsing.NonterminalParser(ToUtf32("arg"), ToUtf32("Operand"), 1)))))));
10692 AddRule(new FloatToIntInstructionRule(ToUtf32("FloatToIntInstruction"), GetScope(), Domain()->GetNextRuleId(),
10693 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
10694 new System.Text.Parsing.GroupingParser(
10695 new System.Text.Parsing.SequenceParser(
10696 new System.Text.Parsing.SequenceParser(
10697 new System.Text.Parsing.KeywordParser(ToUtf32("floattoint")),
10698 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
10699 new System.Text.Parsing.ExpectationParser(
10700 new System.Text.Parsing.NonterminalParser(ToUtf32("arg"), ToUtf32("Operand"), 1)))))));
10701 AddRule(new IntToPtrInstructionRule(ToUtf32("IntToPtrInstruction"), GetScope(), Domain()->GetNextRuleId(),
10702 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
10703 new System.Text.Parsing.GroupingParser(
10704 new System.Text.Parsing.SequenceParser(
10705 new System.Text.Parsing.SequenceParser(
10706 new System.Text.Parsing.KeywordParser(ToUtf32("inttoptr")),
10707 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
10708 new System.Text.Parsing.ExpectationParser(
10709 new System.Text.Parsing.NonterminalParser(ToUtf32("arg"), ToUtf32("Operand"), 1)))))));
10710 AddRule(new PtrToIntInstructionRule(ToUtf32("PtrToIntInstruction"), GetScope(), Domain()->GetNextRuleId(),
10711 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
10712 new System.Text.Parsing.GroupingParser(
10713 new System.Text.Parsing.SequenceParser(
10714 new System.Text.Parsing.SequenceParser(
10715 new System.Text.Parsing.KeywordParser(ToUtf32("ptrtoint")),
10716 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
10717 new System.Text.Parsing.ExpectationParser(
10718 new System.Text.Parsing.NonterminalParser(ToUtf32("arg"), ToUtf32("Operand"), 1)))))));
10719 AddRule(new BinaryInstructionRule(ToUtf32("BinaryInstruction"), GetScope(), Domain()->GetNextRuleId(),
10720 new System.Text.Parsing.AlternativeParser(
10721 new System.Text.Parsing.AlternativeParser(
10722 new System.Text.Parsing.AlternativeParser(
10723 new System.Text.Parsing.AlternativeParser(
10724 new System.Text.Parsing.AlternativeParser(
10725 new System.Text.Parsing.AlternativeParser(
10726 new System.Text.Parsing.AlternativeParser(
10727 new System.Text.Parsing.AlternativeParser(
10728 new System.Text.Parsing.AlternativeParser(
10729 new System.Text.Parsing.AlternativeParser(
10730 new System.Text.Parsing.AlternativeParser(
10731 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
10732 new System.Text.Parsing.NonterminalParser(ToUtf32("AddInstruction"), ToUtf32("AddInstruction"), 2)),
10733 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
10734 new System.Text.Parsing.NonterminalParser(ToUtf32("SubInstruction"), ToUtf32("SubInstruction"), 2))),
10735 new System.Text.Parsing.ActionParser(ToUtf32("A2"),
10736 new System.Text.Parsing.NonterminalParser(ToUtf32("MulInstruction"), ToUtf32("MulInstruction"), 2))),
10737 new System.Text.Parsing.ActionParser(ToUtf32("A3"),
10738 new System.Text.Parsing.NonterminalParser(ToUtf32("DivInstruction"), ToUtf32("DivInstruction"), 2))),
10739 new System.Text.Parsing.ActionParser(ToUtf32("A4"),
10740 new System.Text.Parsing.NonterminalParser(ToUtf32("ModInstruction"), ToUtf32("ModInstruction"), 2))),
10741 new System.Text.Parsing.ActionParser(ToUtf32("A5"),
10742 new System.Text.Parsing.NonterminalParser(ToUtf32("AndInstruction"), ToUtf32("AndInstruction"), 2))),
10743 new System.Text.Parsing.ActionParser(ToUtf32("A6"),
10744 new System.Text.Parsing.NonterminalParser(ToUtf32("OrInstruction"), ToUtf32("OrInstruction"), 2))),
10745 new System.Text.Parsing.ActionParser(ToUtf32("A7"),
10746 new System.Text.Parsing.NonterminalParser(ToUtf32("XorInstruction"), ToUtf32("XorInstruction"), 2))),
10747 new System.Text.Parsing.ActionParser(ToUtf32("A8"),
10748 new System.Text.Parsing.NonterminalParser(ToUtf32("ShlInstruction"), ToUtf32("ShlInstruction"), 2))),
10749 new System.Text.Parsing.ActionParser(ToUtf32("A9"),
10750 new System.Text.Parsing.NonterminalParser(ToUtf32("ShrInstruction"), ToUtf32("ShrInstruction"), 2))),
10751 new System.Text.Parsing.ActionParser(ToUtf32("A10"),
10752 new System.Text.Parsing.NonterminalParser(ToUtf32("EqualInstruction"), ToUtf32("EqualInstruction"), 2))),
10753 new System.Text.Parsing.ActionParser(ToUtf32("A11"),
10754 new System.Text.Parsing.NonterminalParser(ToUtf32("LessInstruction"), ToUtf32("LessInstruction"), 2)))));
10755 AddRule(new AddInstructionRule(ToUtf32("AddInstruction"), GetScope(), Domain()->GetNextRuleId(),
10756 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
10757 new System.Text.Parsing.GroupingParser(
10758 new System.Text.Parsing.SequenceParser(
10759 new System.Text.Parsing.SequenceParser(
10760 new System.Text.Parsing.SequenceParser(
10761 new System.Text.Parsing.SequenceParser(
10762 new System.Text.Parsing.KeywordParser(ToUtf32("add")),
10763 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
10764 new System.Text.Parsing.ExpectationParser(
10765 new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("Operand"), 1))),
10766 new System.Text.Parsing.ExpectationParser(
10767 new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))),
10768 new System.Text.Parsing.ExpectationParser(
10769 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("Operand"), 1)))))));
10770 AddRule(new SubInstructionRule(ToUtf32("SubInstruction"), GetScope(), Domain()->GetNextRuleId(),
10771 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
10772 new System.Text.Parsing.GroupingParser(
10773 new System.Text.Parsing.SequenceParser(
10774 new System.Text.Parsing.SequenceParser(
10775 new System.Text.Parsing.SequenceParser(
10776 new System.Text.Parsing.SequenceParser(
10777 new System.Text.Parsing.KeywordParser(ToUtf32("sub")),
10778 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
10779 new System.Text.Parsing.ExpectationParser(
10780 new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("Operand"), 1))),
10781 new System.Text.Parsing.ExpectationParser(
10782 new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))),
10783 new System.Text.Parsing.ExpectationParser(
10784 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("Operand"), 1)))))));
10785 AddRule(new MulInstructionRule(ToUtf32("MulInstruction"), GetScope(), Domain()->GetNextRuleId(),
10786 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
10787 new System.Text.Parsing.GroupingParser(
10788 new System.Text.Parsing.SequenceParser(
10789 new System.Text.Parsing.SequenceParser(
10790 new System.Text.Parsing.SequenceParser(
10791 new System.Text.Parsing.SequenceParser(
10792 new System.Text.Parsing.KeywordParser(ToUtf32("mul")),
10793 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
10794 new System.Text.Parsing.ExpectationParser(
10795 new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("Operand"), 1))),
10796 new System.Text.Parsing.ExpectationParser(
10797 new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))),
10798 new System.Text.Parsing.ExpectationParser(
10799 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("Operand"), 1)))))));
10800 AddRule(new DivInstructionRule(ToUtf32("DivInstruction"), GetScope(), Domain()->GetNextRuleId(),
10801 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
10802 new System.Text.Parsing.GroupingParser(
10803 new System.Text.Parsing.SequenceParser(
10804 new System.Text.Parsing.SequenceParser(
10805 new System.Text.Parsing.SequenceParser(
10806 new System.Text.Parsing.SequenceParser(
10807 new System.Text.Parsing.KeywordParser(ToUtf32("div")),
10808 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
10809 new System.Text.Parsing.ExpectationParser(
10810 new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("Operand"), 1))),
10811 new System.Text.Parsing.ExpectationParser(
10812 new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))),
10813 new System.Text.Parsing.ExpectationParser(
10814 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("Operand"), 1)))))));
10815 AddRule(new ModInstructionRule(ToUtf32("ModInstruction"), GetScope(), Domain()->GetNextRuleId(),
10816 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
10817 new System.Text.Parsing.GroupingParser(
10818 new System.Text.Parsing.SequenceParser(
10819 new System.Text.Parsing.SequenceParser(
10820 new System.Text.Parsing.SequenceParser(
10821 new System.Text.Parsing.SequenceParser(
10822 new System.Text.Parsing.KeywordParser(ToUtf32("mod")),
10823 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
10824 new System.Text.Parsing.ExpectationParser(
10825 new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("Operand"), 1))),
10826 new System.Text.Parsing.ExpectationParser(
10827 new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))),
10828 new System.Text.Parsing.ExpectationParser(
10829 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("Operand"), 1)))))));
10830 AddRule(new AndInstructionRule(ToUtf32("AndInstruction"), GetScope(), Domain()->GetNextRuleId(),
10831 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
10832 new System.Text.Parsing.GroupingParser(
10833 new System.Text.Parsing.SequenceParser(
10834 new System.Text.Parsing.SequenceParser(
10835 new System.Text.Parsing.SequenceParser(
10836 new System.Text.Parsing.SequenceParser(
10837 new System.Text.Parsing.KeywordParser(ToUtf32("and")),
10838 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
10839 new System.Text.Parsing.ExpectationParser(
10840 new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("Operand"), 1))),
10841 new System.Text.Parsing.ExpectationParser(
10842 new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))),
10843 new System.Text.Parsing.ExpectationParser(
10844 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("Operand"), 1)))))));
10845 AddRule(new OrInstructionRule(ToUtf32("OrInstruction"), GetScope(), Domain()->GetNextRuleId(),
10846 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
10847 new System.Text.Parsing.GroupingParser(
10848 new System.Text.Parsing.SequenceParser(
10849 new System.Text.Parsing.SequenceParser(
10850 new System.Text.Parsing.SequenceParser(
10851 new System.Text.Parsing.SequenceParser(
10852 new System.Text.Parsing.KeywordParser(ToUtf32("or")),
10853 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
10854 new System.Text.Parsing.ExpectationParser(
10855 new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("Operand"), 1))),
10856 new System.Text.Parsing.ExpectationParser(
10857 new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))),
10858 new System.Text.Parsing.ExpectationParser(
10859 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("Operand"), 1)))))));
10860 AddRule(new XorInstructionRule(ToUtf32("XorInstruction"), GetScope(), Domain()->GetNextRuleId(),
10861 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
10862 new System.Text.Parsing.GroupingParser(
10863 new System.Text.Parsing.SequenceParser(
10864 new System.Text.Parsing.SequenceParser(
10865 new System.Text.Parsing.SequenceParser(
10866 new System.Text.Parsing.SequenceParser(
10867 new System.Text.Parsing.KeywordParser(ToUtf32("xor")),
10868 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
10869 new System.Text.Parsing.ExpectationParser(
10870 new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("Operand"), 1))),
10871 new System.Text.Parsing.ExpectationParser(
10872 new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))),
10873 new System.Text.Parsing.ExpectationParser(
10874 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("Operand"), 1)))))));
10875 AddRule(new ShlInstructionRule(ToUtf32("ShlInstruction"), GetScope(), Domain()->GetNextRuleId(),
10876 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
10877 new System.Text.Parsing.GroupingParser(
10878 new System.Text.Parsing.SequenceParser(
10879 new System.Text.Parsing.SequenceParser(
10880 new System.Text.Parsing.SequenceParser(
10881 new System.Text.Parsing.SequenceParser(
10882 new System.Text.Parsing.KeywordParser(ToUtf32("shl")),
10883 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
10884 new System.Text.Parsing.ExpectationParser(
10885 new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("Operand"), 1))),
10886 new System.Text.Parsing.ExpectationParser(
10887 new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))),
10888 new System.Text.Parsing.ExpectationParser(
10889 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("Operand"), 1)))))));
10890 AddRule(new ShrInstructionRule(ToUtf32("ShrInstruction"), GetScope(), Domain()->GetNextRuleId(),
10891 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
10892 new System.Text.Parsing.GroupingParser(
10893 new System.Text.Parsing.SequenceParser(
10894 new System.Text.Parsing.SequenceParser(
10895 new System.Text.Parsing.SequenceParser(
10896 new System.Text.Parsing.SequenceParser(
10897 new System.Text.Parsing.KeywordParser(ToUtf32("shr")),
10898 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
10899 new System.Text.Parsing.ExpectationParser(
10900 new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("Operand"), 1))),
10901 new System.Text.Parsing.ExpectationParser(
10902 new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))),
10903 new System.Text.Parsing.ExpectationParser(
10904 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("Operand"), 1)))))));
10905 AddRule(new EqualInstructionRule(ToUtf32("EqualInstruction"), GetScope(), Domain()->GetNextRuleId(),
10906 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
10907 new System.Text.Parsing.GroupingParser(
10908 new System.Text.Parsing.SequenceParser(
10909 new System.Text.Parsing.SequenceParser(
10910 new System.Text.Parsing.SequenceParser(
10911 new System.Text.Parsing.SequenceParser(
10912 new System.Text.Parsing.KeywordParser(ToUtf32("equal")),
10913 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
10914 new System.Text.Parsing.ExpectationParser(
10915 new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("Operand"), 1))),
10916 new System.Text.Parsing.ExpectationParser(
10917 new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))),
10918 new System.Text.Parsing.ExpectationParser(
10919 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("Operand"), 1)))))));
10920 AddRule(new LessInstructionRule(ToUtf32("LessInstruction"), GetScope(), Domain()->GetNextRuleId(),
10921 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
10922 new System.Text.Parsing.GroupingParser(
10923 new System.Text.Parsing.SequenceParser(
10924 new System.Text.Parsing.SequenceParser(
10925 new System.Text.Parsing.SequenceParser(
10926 new System.Text.Parsing.SequenceParser(
10927 new System.Text.Parsing.KeywordParser(ToUtf32("less")),
10928 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
10929 new System.Text.Parsing.ExpectationParser(
10930 new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("Operand"), 1))),
10931 new System.Text.Parsing.ExpectationParser(
10932 new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))),
10933 new System.Text.Parsing.ExpectationParser(
10934 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("Operand"), 1)))))));
10935 AddRule(new ParamInstructionRule(ToUtf32("ParamInstruction"), GetScope(), Domain()->GetNextRuleId(),
10936 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
10937 new System.Text.Parsing.KeywordParser(ToUtf32("param")))));
10938 AddRule(new LocalInstructionRule(ToUtf32("LocalInstruction"), GetScope(), Domain()->GetNextRuleId(),
10939 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
10940 new System.Text.Parsing.GroupingParser(
10941 new System.Text.Parsing.SequenceParser(
10942 new System.Text.Parsing.SequenceParser(
10943 new System.Text.Parsing.KeywordParser(ToUtf32("local")),
10944 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
10945 new System.Text.Parsing.ExpectationParser(
10946 new System.Text.Parsing.NonterminalParser(ToUtf32("localType"), ToUtf32("TypeExpr"), 1)))))));
10947 AddRule(new LoadInstructionRule(ToUtf32("LoadInstruction"), GetScope(), Domain()->GetNextRuleId(),
10948 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
10949 new System.Text.Parsing.GroupingParser(
10950 new System.Text.Parsing.SequenceParser(
10951 new System.Text.Parsing.SequenceParser(
10952 new System.Text.Parsing.KeywordParser(ToUtf32("load")),
10953 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
10954 new System.Text.Parsing.ExpectationParser(
10955 new System.Text.Parsing.NonterminalParser(ToUtf32("ptr"), ToUtf32("Operand"), 1)))))));
10956 AddRule(new ElemAddrInstructionRule(ToUtf32("ElemAddrInstruction"), GetScope(), Domain()->GetNextRuleId(),
10957 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
10958 new System.Text.Parsing.GroupingParser(
10959 new System.Text.Parsing.SequenceParser(
10960 new System.Text.Parsing.SequenceParser(
10961 new System.Text.Parsing.SequenceParser(
10962 new System.Text.Parsing.SequenceParser(
10963 new System.Text.Parsing.KeywordParser(ToUtf32("elemaddr")),
10964 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
10965 new System.Text.Parsing.ExpectationParser(
10966 new System.Text.Parsing.NonterminalParser(ToUtf32("ptr"), ToUtf32("Operand"), 1))),
10967 new System.Text.Parsing.ExpectationParser(
10968 new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))),
10969 new System.Text.Parsing.ExpectationParser(
10970 new System.Text.Parsing.NonterminalParser(ToUtf32("index"), ToUtf32("Operand"), 1)))))));
10971 AddRule(new PtrOffsetInstructionRule(ToUtf32("PtrOffsetInstruction"), GetScope(), Domain()->GetNextRuleId(),
10972 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
10973 new System.Text.Parsing.GroupingParser(
10974 new System.Text.Parsing.SequenceParser(
10975 new System.Text.Parsing.SequenceParser(
10976 new System.Text.Parsing.SequenceParser(
10977 new System.Text.Parsing.SequenceParser(
10978 new System.Text.Parsing.KeywordParser(ToUtf32("ptroffset")),
10979 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
10980 new System.Text.Parsing.ExpectationParser(
10981 new System.Text.Parsing.NonterminalParser(ToUtf32("ptr"), ToUtf32("Operand"), 1))),
10982 new System.Text.Parsing.ExpectationParser(
10983 new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))),
10984 new System.Text.Parsing.ExpectationParser(
10985 new System.Text.Parsing.NonterminalParser(ToUtf32("offset"), ToUtf32("Operand"), 1)))))));
10986 AddRule(new PtrDiffInstructionRule(ToUtf32("PtrDiffInstruction"), GetScope(), Domain()->GetNextRuleId(),
10987 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
10988 new System.Text.Parsing.GroupingParser(
10989 new System.Text.Parsing.SequenceParser(
10990 new System.Text.Parsing.SequenceParser(
10991 new System.Text.Parsing.SequenceParser(
10992 new System.Text.Parsing.SequenceParser(
10993 new System.Text.Parsing.KeywordParser(ToUtf32("ptrdiff")),
10994 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
10995 new System.Text.Parsing.ExpectationParser(
10996 new System.Text.Parsing.NonterminalParser(ToUtf32("leftPtr"), ToUtf32("Operand"), 1))),
10997 new System.Text.Parsing.ExpectationParser(
10998 new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))),
10999 new System.Text.Parsing.ExpectationParser(
11000 new System.Text.Parsing.NonterminalParser(ToUtf32("rightPtr"), ToUtf32("Operand"), 1)))))));
11001 AddRule(new FunctionCallInstructionRule(ToUtf32("FunctionCallInstruction"), GetScope(), Domain()->GetNextRuleId(),
11002 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11003 new System.Text.Parsing.GroupingParser(
11004 new System.Text.Parsing.SequenceParser(
11005 new System.Text.Parsing.SequenceParser(
11006 new System.Text.Parsing.SequenceParser(
11007 new System.Text.Parsing.SequenceParser(
11008 new System.Text.Parsing.KeywordParser(ToUtf32("call")),
11009 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
11010 new System.Text.Parsing.ExpectationParser(
11011 new System.Text.Parsing.NonterminalParser(ToUtf32("functionType"), ToUtf32("TypeExpr"), 1))),
11012 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
11013 new System.Text.Parsing.ExpectationParser(
11014 new System.Text.Parsing.NonterminalParser(ToUtf32("callee"), ToUtf32("Value"), 2)))))));
11015 AddRule(new TrapInstructionRule(ToUtf32("TrapInstruction"), GetScope(), Domain()->GetNextRuleId(),
11016 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11017 new System.Text.Parsing.GroupingParser(
11018 new System.Text.Parsing.SequenceParser(
11019 new System.Text.Parsing.SequenceParser(
11020 new System.Text.Parsing.SequenceParser(
11021 new System.Text.Parsing.SequenceParser(
11022 new System.Text.Parsing.SequenceParser(
11023 new System.Text.Parsing.SequenceParser(
11024 new System.Text.Parsing.SequenceParser(
11025 new System.Text.Parsing.SequenceParser(
11026 new System.Text.Parsing.SequenceParser(
11027 new System.Text.Parsing.SequenceParser(
11028 new System.Text.Parsing.SequenceParser(
11029 new System.Text.Parsing.SequenceParser(
11030 new System.Text.Parsing.KeywordParser(ToUtf32("trap")),
11031 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
11032 new System.Text.Parsing.ExpectationParser(
11033 new System.Text.Parsing.NonterminalParser(ToUtf32("type1"), ToUtf32("TypeExpr"), 1))),
11034 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
11035 new System.Text.Parsing.ExpectationParser(
11036 new System.Text.Parsing.NonterminalParser(ToUtf32("val1"), ToUtf32("Value"), 2))),
11037 new System.Text.Parsing.ExpectationParser(
11038 new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))),
11039 new System.Text.Parsing.ExpectationParser(
11040 new System.Text.Parsing.NonterminalParser(ToUtf32("type2"), ToUtf32("TypeExpr"), 1))),
11041 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
11042 new System.Text.Parsing.ExpectationParser(
11043 new System.Text.Parsing.NonterminalParser(ToUtf32("val2"), ToUtf32("Value"), 2))),
11044 new System.Text.Parsing.ExpectationParser(
11045 new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))),
11046 new System.Text.Parsing.ExpectationParser(
11047 new System.Text.Parsing.NonterminalParser(ToUtf32("type3"), ToUtf32("TypeExpr"), 1))),
11048 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
11049 new System.Text.Parsing.ExpectationParser(
11050 new System.Text.Parsing.NonterminalParser(ToUtf32("val3"), ToUtf32("Value"), 2)))))));
11051 AddRule(new OperandRule(ToUtf32("Operand"), GetScope(), Domain()->GetNextRuleId(),
11052 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11053 new System.Text.Parsing.GroupingParser(
11054 new System.Text.Parsing.SequenceParser(
11055 new System.Text.Parsing.SequenceParser(
11056 new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("TypeExpr"), 1),
11057 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
11058 new System.Text.Parsing.ExpectationParser(
11059 new System.Text.Parsing.NonterminalParser(ToUtf32("val"), ToUtf32("Value"), 2)))))));
11060 AddRule(new LabelRule(ToUtf32("Label"), GetScope(), Domain()->GetNextRuleId(),
11061 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11062 new System.Text.Parsing.TokenParser(
11063 new System.Text.Parsing.SequenceParser(
11064 new System.Text.Parsing.CharParser('@'),
11065 new System.Text.Parsing.NonterminalParser(ToUtf32("x"), ToUtf32("uint"), 0))))));
11066 AddRule(new ValueRule(ToUtf32("Value"), GetScope(), Domain()->GetNextRuleId(),
11067 new System.Text.Parsing.AlternativeParser(
11068 new System.Text.Parsing.AlternativeParser(
11069 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11070 new System.Text.Parsing.NonterminalParser(ToUtf32("IdValue"), ToUtf32("IdValue"), 2)),
11071 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
11072 new System.Text.Parsing.NonterminalParser(ToUtf32("SymbolValue"), ToUtf32("SymbolValue"), 2))),
11073 new System.Text.Parsing.ActionParser(ToUtf32("A2"),
11074 new System.Text.Parsing.NonterminalParser(ToUtf32("LiteralValue"), ToUtf32("LiteralValue"), 2)))));
11075 AddRule(new IdValueRule(ToUtf32("IdValue"), GetScope(), Domain()->GetNextRuleId(),
11076 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11077 new System.Text.Parsing.GroupingParser(
11078 new System.Text.Parsing.SequenceParser(
11079 new System.Text.Parsing.CharParser('$'),
11080 new System.Text.Parsing.NonterminalParser(ToUtf32("x"), ToUtf32("uint"), 0))))));
11081 AddRule(new SymbolValueRule(ToUtf32("SymbolValue"), GetScope(), Domain()->GetNextRuleId(),
11082 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11083 new System.Text.Parsing.TokenParser(
11084 new System.Text.Parsing.SequenceParser(
11085 new System.Text.Parsing.CharParser('@'),
11086 new System.Text.Parsing.NonterminalParser(ToUtf32("identifier"), ToUtf32("identifier"), 0))))));
11087 AddRule(new LiteralValueRule(ToUtf32("LiteralValue"), GetScope(), Domain()->GetNextRuleId(),
11088 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11089 new System.Text.Parsing.GroupingParser(
11090 new System.Text.Parsing.PositiveParser(
11091 new System.Text.Parsing.TokenParser(
11092 new System.Text.Parsing.DifferenceParser(
11093 new System.Text.Parsing.AnyCharParser(),
11094 new System.Text.Parsing.GroupingParser(
11095 new System.Text.Parsing.AlternativeParser(
11096 new System.Text.Parsing.AlternativeParser(
11097 new System.Text.Parsing.AlternativeParser(
11098 new System.Text.Parsing.CharParser(','),
11099 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
11100 new System.Text.Parsing.CharParser(')')),
11101 new System.Text.Parsing.NonterminalParser(ToUtf32("newline"), ToUtf32("newline"), 0))))))))));
11102 AddRule(new System.Text.Parsing.RuleParser(ToUtf32("S"), GetScope(), Domain()->GetNextRuleId(),
11103 new System.Text.Parsing.PositiveParser(
11104 new System.Text.Parsing.CharSetParser(ToUtf32(" \t")))));
11105 AddRule(new System.Text.Parsing.RuleParser(ToUtf32("Comma"), GetScope(), Domain()->GetNextRuleId(),
11106 new System.Text.Parsing.SequenceParser(
11107 new System.Text.Parsing.SequenceParser(
11108 new System.Text.Parsing.OptionalParser(
11109 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
11110 new System.Text.Parsing.CharParser(',')),
11111 new System.Text.Parsing.OptionalParser(
11112 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)))));
11113 AddRule(new VariableNameRule(ToUtf32("VariableName"), GetScope(), Domain()->GetNextRuleId(),
11114 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11115 new System.Text.Parsing.TokenParser(
11116 new System.Text.Parsing.SequenceParser(
11117 new System.Text.Parsing.GroupingParser(
11118 new System.Text.Parsing.AlternativeParser(
11119 new System.Text.Parsing.AlternativeParser(
11120 new System.Text.Parsing.IdStartParser(),
11121 new System.Text.Parsing.CharParser('_')),
11122 new System.Text.Parsing.CharParser('@'))),
11123 new System.Text.Parsing.KleeneStarParser(
11124 new System.Text.Parsing.GroupingParser(
11125 new System.Text.Parsing.AlternativeParser(
11126 new System.Text.Parsing.IdContParser(),
11127 new System.Text.Parsing.CharParser('@')))))))));
11128 AddRule(new TypeDeclarationRule(ToUtf32("TypeDeclaration"), GetScope(), Domain()->GetNextRuleId(),
11129 new System.Text.Parsing.SequenceParser(
11130 new System.Text.Parsing.SequenceParser(
11131 new System.Text.Parsing.SequenceParser(
11132 new System.Text.Parsing.NonterminalParser(ToUtf32("typeId"), ToUtf32("StrTypeId"), 1),
11133 new System.Text.Parsing.ExpectationParser(
11134 new System.Text.Parsing.CharParser('='))),
11135 new System.Text.Parsing.ExpectationParser(
11136 new System.Text.Parsing.KeywordParser(ToUtf32("type")))),
11137 new System.Text.Parsing.GroupingParser(
11138 new System.Text.Parsing.AlternativeParser(
11139 new System.Text.Parsing.AlternativeParser(
11140 new System.Text.Parsing.NonterminalParser(ToUtf32("StructureType"), ToUtf32("StructureType"), 2),
11141 new System.Text.Parsing.NonterminalParser(ToUtf32("ArrayType"), ToUtf32("ArrayType"), 2)),
11142 new System.Text.Parsing.NonterminalParser(ToUtf32("FunctionType"), ToUtf32("FunctionType"), 2))))));
11143 AddRule(new StructureTypeRule(ToUtf32("StructureType"), GetScope(), Domain()->GetNextRuleId(),
11144 new System.Text.Parsing.SequenceParser(
11145 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11146 new System.Text.Parsing.GroupingParser(
11147 new System.Text.Parsing.SequenceParser(
11148 new System.Text.Parsing.SequenceParser(
11149 new System.Text.Parsing.CharParser('{'),
11150 new System.Text.Parsing.OptionalParser(
11151 new System.Text.Parsing.GroupingParser(
11152 new System.Text.Parsing.ListParser(
11153 new System.Text.Parsing.GroupingParser(
11154 new System.Text.Parsing.SequenceParser(
11155 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
11156 new System.Text.Parsing.ExpectationParser(
11157 new System.Text.Parsing.NonterminalParser(ToUtf32("StrTypeId"), ToUtf32("StrTypeId"), 1))),
11158 new System.Text.Parsing.OptionalParser(
11159 new System.Text.Parsing.GroupingParser(
11160 new System.Text.Parsing.SequenceParser(
11161 new System.Text.Parsing.SequenceParser(
11162 new System.Text.Parsing.SequenceParser(
11163 new System.Text.Parsing.CharParser(':'),
11164 new System.Text.Parsing.StringParser(ToUtf32("offset"))),
11165 new System.Text.Parsing.CharParser('=')),
11166 new System.Text.Parsing.NonterminalParser(ToUtf32("long"), ToUtf32("long"), 0)))))),
11167 new System.Text.Parsing.CharParser(','))))),
11168 new System.Text.Parsing.ExpectationParser(
11169 new System.Text.Parsing.CharParser('}'))))),
11170 new System.Text.Parsing.OptionalParser(
11171 new System.Text.Parsing.GroupingParser(
11172 new System.Text.Parsing.SequenceParser(
11173 new System.Text.Parsing.SequenceParser(
11174 new System.Text.Parsing.SequenceParser(
11175 new System.Text.Parsing.SequenceParser(
11176 new System.Text.Parsing.SequenceParser(
11177 new System.Text.Parsing.SequenceParser(
11178 new System.Text.Parsing.KeywordParser(ToUtf32("size")),
11179 new System.Text.Parsing.CharParser('=')),
11180 new System.Text.Parsing.NonterminalParser(ToUtf32("sz"), ToUtf32("long"), 0)),
11181 new System.Text.Parsing.CharParser(',')),
11182 new System.Text.Parsing.KeywordParser(ToUtf32("alignment"))),
11183 new System.Text.Parsing.CharParser('=')),
11184 new System.Text.Parsing.NonterminalParser(ToUtf32("al"), ToUtf32("long"), 0)))))));
11185 AddRule(new ArrayTypeRule(ToUtf32("ArrayType"), GetScope(), Domain()->GetNextRuleId(),
11186 new System.Text.Parsing.SequenceParser(
11187 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11188 new System.Text.Parsing.GroupingParser(
11189 new System.Text.Parsing.SequenceParser(
11190 new System.Text.Parsing.SequenceParser(
11191 new System.Text.Parsing.SequenceParser(
11192 new System.Text.Parsing.SequenceParser(
11193 new System.Text.Parsing.CharParser('['),
11194 new System.Text.Parsing.ExpectationParser(
11195 new System.Text.Parsing.NonterminalParser(ToUtf32("size"), ToUtf32("long"), 0))),
11196 new System.Text.Parsing.ExpectationParser(
11197 new System.Text.Parsing.CharParser('x'))),
11198 new System.Text.Parsing.ExpectationParser(
11199 new System.Text.Parsing.NonterminalParser(ToUtf32("elementTypeId"), ToUtf32("StrTypeId"), 1))),
11200 new System.Text.Parsing.ExpectationParser(
11201 new System.Text.Parsing.CharParser(']'))))),
11202 new System.Text.Parsing.OptionalParser(
11203 new System.Text.Parsing.GroupingParser(
11204 new System.Text.Parsing.SequenceParser(
11205 new System.Text.Parsing.SequenceParser(
11206 new System.Text.Parsing.SequenceParser(
11207 new System.Text.Parsing.SequenceParser(
11208 new System.Text.Parsing.SequenceParser(
11209 new System.Text.Parsing.SequenceParser(
11210 new System.Text.Parsing.KeywordParser(ToUtf32("size")),
11211 new System.Text.Parsing.CharParser('=')),
11212 new System.Text.Parsing.NonterminalParser(ToUtf32("sz"), ToUtf32("long"), 0)),
11213 new System.Text.Parsing.CharParser(',')),
11214 new System.Text.Parsing.KeywordParser(ToUtf32("alignment"))),
11215 new System.Text.Parsing.CharParser('=')),
11216 new System.Text.Parsing.NonterminalParser(ToUtf32("al"), ToUtf32("long"), 0)))))));
11217 AddRule(new FunctionTypeRule(ToUtf32("FunctionType"), GetScope(), Domain()->GetNextRuleId(),
11218 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11219 new System.Text.Parsing.GroupingParser(
11220 new System.Text.Parsing.SequenceParser(
11221 new System.Text.Parsing.SequenceParser(
11222 new System.Text.Parsing.SequenceParser(
11223 new System.Text.Parsing.SequenceParser(
11224 new System.Text.Parsing.KeywordParser(ToUtf32("function")),
11225 new System.Text.Parsing.ExpectationParser(
11226 new System.Text.Parsing.NonterminalParser(ToUtf32("returnTypeId"), ToUtf32("StrTypeId"), 1))),
11227 new System.Text.Parsing.ExpectationParser(
11228 new System.Text.Parsing.CharParser('('))),
11229 new System.Text.Parsing.OptionalParser(
11230 new System.Text.Parsing.GroupingParser(
11231 new System.Text.Parsing.ListParser(
11232 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
11233 new System.Text.Parsing.NonterminalParser(ToUtf32("paramType"), ToUtf32("StrTypeId"), 1)),
11234 new System.Text.Parsing.CharParser(','))))),
11235 new System.Text.Parsing.ExpectationParser(
11236 new System.Text.Parsing.CharParser(')')))))));
11237 AddRule(new StrTypeIdRule(ToUtf32("StrTypeId"), GetScope(), Domain()->GetNextRuleId(),
11238 new System.Text.Parsing.SequenceParser(
11239 new System.Text.Parsing.GroupingParser(
11240 new System.Text.Parsing.AlternativeParser(
11241 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11242 new System.Text.Parsing.TokenParser(
11243 new System.Text.Parsing.SequenceParser(
11244 new System.Text.Parsing.StringParser(ToUtf32("$T")),
11245 new System.Text.Parsing.NonterminalParser(ToUtf32("uint"), ToUtf32("uint"), 0)))),
11246 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
11247 new System.Text.Parsing.GroupingParser(
11248 new System.Text.Parsing.KeywordListParser(ToUtf32("identifier"), keywords0))))),
11249 new System.Text.Parsing.KleeneStarParser(
11250 new System.Text.Parsing.GroupingParser(
11251 new System.Text.Parsing.ActionParser(ToUtf32("A2"),
11252 new System.Text.Parsing.GroupingParser(
11253 new System.Text.Parsing.CharParser('*'))))))));
11254 AddRule(new TypeExprRule(ToUtf32("TypeExpr"), GetScope(), Domain()->GetNextRuleId(),
11255 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11256 new System.Text.Parsing.NonterminalParser(ToUtf32("PostfixTypeExpr"), ToUtf32("PostfixTypeExpr"), 1))));
11257 AddRule(new PostfixTypeExprRule(ToUtf32("PostfixTypeExpr"), GetScope(), Domain()->GetNextRuleId(),
11258 new System.Text.Parsing.SequenceParser(
11259 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11260 new System.Text.Parsing.NonterminalParser(ToUtf32("PrimaryTypeExpr"), ToUtf32("PrimaryTypeExpr"), 1)),
11261 new System.Text.Parsing.KleeneStarParser(
11262 new System.Text.Parsing.GroupingParser(
11263 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
11264 new System.Text.Parsing.CharParser('*')))))));
11265 AddRule(new PrimaryTypeExprRule(ToUtf32("PrimaryTypeExpr"), GetScope(), Domain()->GetNextRuleId(),
11266 new System.Text.Parsing.AlternativeParser(
11267 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11268 new System.Text.Parsing.NonterminalParser(ToUtf32("TypeId"), ToUtf32("TypeId"), 1)),
11269 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
11270 new System.Text.Parsing.NonterminalParser(ToUtf32("PrimitiveType"), ToUtf32("PrimitiveType"), 1)))));
11271 AddRule(new TypeIdRule(ToUtf32("TypeId"), GetScope(), Domain()->GetNextRuleId(),
11272 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11273 new System.Text.Parsing.TokenParser(
11274 new System.Text.Parsing.SequenceParser(
11275 new System.Text.Parsing.StringParser(ToUtf32("$T")),
11276 new System.Text.Parsing.NonterminalParser(ToUtf32("uint"), ToUtf32("uint"), 0))))));
11277 AddRule(new PrimitiveTypeRule(ToUtf32("PrimitiveType"), GetScope(), Domain()->GetNextRuleId(),
11278 new System.Text.Parsing.AlternativeParser(
11279 new System.Text.Parsing.AlternativeParser(
11280 new System.Text.Parsing.AlternativeParser(
11281 new System.Text.Parsing.AlternativeParser(
11282 new System.Text.Parsing.AlternativeParser(
11283 new System.Text.Parsing.AlternativeParser(
11284 new System.Text.Parsing.AlternativeParser(
11285 new System.Text.Parsing.AlternativeParser(
11286 new System.Text.Parsing.AlternativeParser(
11287 new System.Text.Parsing.AlternativeParser(
11288 new System.Text.Parsing.AlternativeParser(
11289 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11290 new System.Text.Parsing.NonterminalParser(ToUtf32("VoidType"), ToUtf32("VoidType"), 1)),
11291 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
11292 new System.Text.Parsing.NonterminalParser(ToUtf32("BoolType"), ToUtf32("BoolType"), 1))),
11293 new System.Text.Parsing.ActionParser(ToUtf32("A2"),
11294 new System.Text.Parsing.NonterminalParser(ToUtf32("SByteType"), ToUtf32("SByteType"), 1))),
11295 new System.Text.Parsing.ActionParser(ToUtf32("A3"),
11296 new System.Text.Parsing.NonterminalParser(ToUtf32("ByteType"), ToUtf32("ByteType"), 1))),
11297 new System.Text.Parsing.ActionParser(ToUtf32("A4"),
11298 new System.Text.Parsing.NonterminalParser(ToUtf32("ShortType"), ToUtf32("ShortType"), 1))),
11299 new System.Text.Parsing.ActionParser(ToUtf32("A5"),
11300 new System.Text.Parsing.NonterminalParser(ToUtf32("UShortType"), ToUtf32("UShortType"), 1))),
11301 new System.Text.Parsing.ActionParser(ToUtf32("A6"),
11302 new System.Text.Parsing.NonterminalParser(ToUtf32("IntType"), ToUtf32("IntType"), 1))),
11303 new System.Text.Parsing.ActionParser(ToUtf32("A7"),
11304 new System.Text.Parsing.NonterminalParser(ToUtf32("UIntType"), ToUtf32("UIntType"), 1))),
11305 new System.Text.Parsing.ActionParser(ToUtf32("A8"),
11306 new System.Text.Parsing.NonterminalParser(ToUtf32("LongType"), ToUtf32("LongType"), 1))),
11307 new System.Text.Parsing.ActionParser(ToUtf32("A9"),
11308 new System.Text.Parsing.NonterminalParser(ToUtf32("ULongType"), ToUtf32("ULongType"), 1))),
11309 new System.Text.Parsing.ActionParser(ToUtf32("A10"),
11310 new System.Text.Parsing.NonterminalParser(ToUtf32("FloatType"), ToUtf32("FloatType"), 1))),
11311 new System.Text.Parsing.ActionParser(ToUtf32("A11"),
11312 new System.Text.Parsing.NonterminalParser(ToUtf32("DoubleType"), ToUtf32("DoubleType"), 1)))));
11313 AddRule(new VoidTypeRule(ToUtf32("VoidType"), GetScope(), Domain()->GetNextRuleId(),
11314 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11315 new System.Text.Parsing.KeywordParser(ToUtf32("void")))));
11316 AddRule(new BoolTypeRule(ToUtf32("BoolType"), GetScope(), Domain()->GetNextRuleId(),
11317 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11318 new System.Text.Parsing.KeywordParser(ToUtf32("bool")))));
11319 AddRule(new SByteTypeRule(ToUtf32("SByteType"), GetScope(), Domain()->GetNextRuleId(),
11320 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11321 new System.Text.Parsing.KeywordParser(ToUtf32("sbyte")))));
11322 AddRule(new ByteTypeRule(ToUtf32("ByteType"), GetScope(), Domain()->GetNextRuleId(),
11323 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11324 new System.Text.Parsing.KeywordParser(ToUtf32("byte")))));
11325 AddRule(new ShortTypeRule(ToUtf32("ShortType"), GetScope(), Domain()->GetNextRuleId(),
11326 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11327 new System.Text.Parsing.KeywordParser(ToUtf32("short")))));
11328 AddRule(new UShortTypeRule(ToUtf32("UShortType"), GetScope(), Domain()->GetNextRuleId(),
11329 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11330 new System.Text.Parsing.KeywordParser(ToUtf32("ushort")))));
11331 AddRule(new IntTypeRule(ToUtf32("IntType"), GetScope(), Domain()->GetNextRuleId(),
11332 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11333 new System.Text.Parsing.KeywordParser(ToUtf32("int")))));
11334 AddRule(new UIntTypeRule(ToUtf32("UIntType"), GetScope(), Domain()->GetNextRuleId(),
11335 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11336 new System.Text.Parsing.KeywordParser(ToUtf32("uint")))));
11337 AddRule(new LongTypeRule(ToUtf32("LongType"), GetScope(), Domain()->GetNextRuleId(),
11338 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11339 new System.Text.Parsing.KeywordParser(ToUtf32("long")))));
11340 AddRule(new ULongTypeRule(ToUtf32("ULongType"), GetScope(), Domain()->GetNextRuleId(),
11341 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11342 new System.Text.Parsing.KeywordParser(ToUtf32("ulong")))));
11343 AddRule(new FloatTypeRule(ToUtf32("FloatType"), GetScope(), Domain()->GetNextRuleId(),
11344 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11345 new System.Text.Parsing.KeywordParser(ToUtf32("float")))));
11346 AddRule(new DoubleTypeRule(ToUtf32("DoubleType"), GetScope(), Domain()->GetNextRuleId(),
11347 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11348 new System.Text.Parsing.KeywordParser(ToUtf32("double")))));
11349 AddRule(new DataDefinitionRule(ToUtf32("DataDefinition"), GetScope(), Domain()->GetNextRuleId(),
11350 new System.Text.Parsing.SequenceParser(
11351 new System.Text.Parsing.SequenceParser(
11352 new System.Text.Parsing.SequenceParser(
11353 new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("TypeExpr"), 1),
11354 new System.Text.Parsing.OptionalParser(
11355 new System.Text.Parsing.GroupingParser(
11356 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11357 new System.Text.Parsing.KeywordParser(ToUtf32("once")))))),
11358 new System.Text.Parsing.ExpectationParser(
11359 new System.Text.Parsing.NonterminalParser(ToUtf32("name"), ToUtf32("VariableName"), 0))),
11360 new System.Text.Parsing.GroupingParser(
11361 new System.Text.Parsing.AlternativeParser(
11362 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
11363 new System.Text.Parsing.CharParser(';')),
11364 new System.Text.Parsing.SequenceParser(
11365 new System.Text.Parsing.ExpectationParser(
11366 new System.Text.Parsing.CharParser('=')),
11367 new System.Text.Parsing.ActionParser(ToUtf32("A2"),
11368 new System.Text.Parsing.NonterminalParser(ToUtf32("Constant"), ToUtf32("Constant"), 1))))))));
11369 AddRule(new ConstantRule(ToUtf32("Constant"), GetScope(), Domain()->GetNextRuleId(),
11370 new System.Text.Parsing.AlternativeParser(
11371 new System.Text.Parsing.AlternativeParser(
11372 new System.Text.Parsing.AlternativeParser(
11373 new System.Text.Parsing.AlternativeParser(
11374 new System.Text.Parsing.AlternativeParser(
11375 new System.Text.Parsing.AlternativeParser(
11376 new System.Text.Parsing.AlternativeParser(
11377 new System.Text.Parsing.AlternativeParser(
11378 new System.Text.Parsing.AlternativeParser(
11379 new System.Text.Parsing.AlternativeParser(
11380 new System.Text.Parsing.AlternativeParser(
11381 new System.Text.Parsing.AlternativeParser(
11382 new System.Text.Parsing.AlternativeParser(
11383 new System.Text.Parsing.AlternativeParser(
11384 new System.Text.Parsing.AlternativeParser(
11385 new System.Text.Parsing.AlternativeParser(
11386 new System.Text.Parsing.AlternativeParser(
11387 new System.Text.Parsing.AlternativeParser(
11388 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11389 new System.Text.Parsing.NonterminalParser(ToUtf32("ConversionConstant"), ToUtf32("ConversionConstant"), 1)),
11390 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
11391 new System.Text.Parsing.NonterminalParser(ToUtf32("ClsIdConstant"), ToUtf32("ClsIdConstant"), 1))),
11392 new System.Text.Parsing.ActionParser(ToUtf32("A2"),
11393 new System.Text.Parsing.NonterminalParser(ToUtf32("PtrConstant"), ToUtf32("PtrConstant"), 1))),
11394 new System.Text.Parsing.ActionParser(ToUtf32("A3"),
11395 new System.Text.Parsing.NonterminalParser(ToUtf32("SymbolConstant"), ToUtf32("SymbolConstant"), 1))),
11396 new System.Text.Parsing.ActionParser(ToUtf32("A4"),
11397 new System.Text.Parsing.NonterminalParser(ToUtf32("BoolConstant"), ToUtf32("BoolConstant"), 1))),
11398 new System.Text.Parsing.ActionParser(ToUtf32("A5"),
11399 new System.Text.Parsing.NonterminalParser(ToUtf32("SByteConstant"), ToUtf32("SByteConstant"), 1))),
11400 new System.Text.Parsing.ActionParser(ToUtf32("A6"),
11401 new System.Text.Parsing.NonterminalParser(ToUtf32("ByteConstant"), ToUtf32("ByteConstant"), 1))),
11402 new System.Text.Parsing.ActionParser(ToUtf32("A7"),
11403 new System.Text.Parsing.NonterminalParser(ToUtf32("ShortConstant"), ToUtf32("ShortConstant"), 1))),
11404 new System.Text.Parsing.ActionParser(ToUtf32("A8"),
11405 new System.Text.Parsing.NonterminalParser(ToUtf32("UShortConstant"), ToUtf32("UShortConstant"), 1))),
11406 new System.Text.Parsing.ActionParser(ToUtf32("A9"),
11407 new System.Text.Parsing.NonterminalParser(ToUtf32("IntConstant"), ToUtf32("IntConstant"), 1))),
11408 new System.Text.Parsing.ActionParser(ToUtf32("A10"),
11409 new System.Text.Parsing.NonterminalParser(ToUtf32("UIntConstant"), ToUtf32("UIntConstant"), 1))),
11410 new System.Text.Parsing.ActionParser(ToUtf32("A11"),
11411 new System.Text.Parsing.NonterminalParser(ToUtf32("LongConstant"), ToUtf32("LongConstant"), 1))),
11412 new System.Text.Parsing.ActionParser(ToUtf32("A12"),
11413 new System.Text.Parsing.NonterminalParser(ToUtf32("ULongConstant"), ToUtf32("ULongConstant"), 1))),
11414 new System.Text.Parsing.ActionParser(ToUtf32("A13"),
11415 new System.Text.Parsing.NonterminalParser(ToUtf32("FloatConstant"), ToUtf32("FloatConstant"), 1))),
11416 new System.Text.Parsing.ActionParser(ToUtf32("A14"),
11417 new System.Text.Parsing.NonterminalParser(ToUtf32("DoubleConstant"), ToUtf32("DoubleConstant"), 1))),
11418 new System.Text.Parsing.ActionParser(ToUtf32("A15"),
11419 new System.Text.Parsing.NonterminalParser(ToUtf32("ArrayConstant"), ToUtf32("ArrayConstant"), 1))),
11420 new System.Text.Parsing.ActionParser(ToUtf32("A16"),
11421 new System.Text.Parsing.NonterminalParser(ToUtf32("StructureConstant"), ToUtf32("StructureConstant"), 1))),
11422 new System.Text.Parsing.ActionParser(ToUtf32("A17"),
11423 new System.Text.Parsing.NonterminalParser(ToUtf32("StringConstant"), ToUtf32("StringConstant"), 1))),
11424 new System.Text.Parsing.ActionParser(ToUtf32("A18"),
11425 new System.Text.Parsing.NonterminalParser(ToUtf32("StringArrayConstant"), ToUtf32("StringArrayConstant"), 1)))));
11426 AddRule(new BoolConstantRule(ToUtf32("BoolConstant"), GetScope(), Domain()->GetNextRuleId(),
11427 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11428 new System.Text.Parsing.GroupingParser(
11429 new System.Text.Parsing.SequenceParser(
11430 new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("BoolType"), 1),
11431 new System.Text.Parsing.NonterminalParser(ToUtf32("val"), ToUtf32("BoolValue"), 0))))));
11432 AddRule(new BoolValueRule(ToUtf32("BoolValue"), GetScope(), Domain()->GetNextRuleId(),
11433 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11434 new System.Text.Parsing.NonterminalParser(ToUtf32("x"), ToUtf32("bool"), 0))));
11435 AddRule(new SByteConstantRule(ToUtf32("SByteConstant"), GetScope(), Domain()->GetNextRuleId(),
11436 new System.Text.Parsing.SequenceParser(
11437 new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("SByteType"), 1),
11438 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11439 new System.Text.Parsing.NonterminalParser(ToUtf32("val"), ToUtf32("SByteValue"), 0)))));
11440 AddRule(new SByteValueRule(ToUtf32("SByteValue"), GetScope(), Domain()->GetNextRuleId(),
11441 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11442 new System.Text.Parsing.NonterminalParser(ToUtf32("x"), ToUtf32("sbyte"), 0))));
11443 AddRule(new ByteConstantRule(ToUtf32("ByteConstant"), GetScope(), Domain()->GetNextRuleId(),
11444 new System.Text.Parsing.SequenceParser(
11445 new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("ByteType"), 1),
11446 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11447 new System.Text.Parsing.NonterminalParser(ToUtf32("val"), ToUtf32("ByteValue"), 0)))));
11448 AddRule(new ByteValueRule(ToUtf32("ByteValue"), GetScope(), Domain()->GetNextRuleId(),
11449 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11450 new System.Text.Parsing.NonterminalParser(ToUtf32("x"), ToUtf32("byte"), 0))));
11451 AddRule(new ShortConstantRule(ToUtf32("ShortConstant"), GetScope(), Domain()->GetNextRuleId(),
11452 new System.Text.Parsing.SequenceParser(
11453 new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("ShortType"), 1),
11454 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11455 new System.Text.Parsing.NonterminalParser(ToUtf32("val"), ToUtf32("ShortValue"), 0)))));
11456 AddRule(new ShortValueRule(ToUtf32("ShortValue"), GetScope(), Domain()->GetNextRuleId(),
11457 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11458 new System.Text.Parsing.NonterminalParser(ToUtf32("x"), ToUtf32("short"), 0))));
11459 AddRule(new UShortConstantRule(ToUtf32("UShortConstant"), GetScope(), Domain()->GetNextRuleId(),
11460 new System.Text.Parsing.SequenceParser(
11461 new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("UShortType"), 1),
11462 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11463 new System.Text.Parsing.NonterminalParser(ToUtf32("val"), ToUtf32("UShortValue"), 0)))));
11464 AddRule(new UShortValueRule(ToUtf32("UShortValue"), GetScope(), Domain()->GetNextRuleId(),
11465 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11466 new System.Text.Parsing.NonterminalParser(ToUtf32("x"), ToUtf32("ushort"), 0))));
11467 AddRule(new IntConstantRule(ToUtf32("IntConstant"), GetScope(), Domain()->GetNextRuleId(),
11468 new System.Text.Parsing.SequenceParser(
11469 new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("IntType"), 1),
11470 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11471 new System.Text.Parsing.NonterminalParser(ToUtf32("val"), ToUtf32("IntValue"), 0)))));
11472 AddRule(new IntValueRule(ToUtf32("IntValue"), GetScope(), Domain()->GetNextRuleId(),
11473 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11474 new System.Text.Parsing.NonterminalParser(ToUtf32("x"), ToUtf32("int"), 0))));
11475 AddRule(new UIntConstantRule(ToUtf32("UIntConstant"), GetScope(), Domain()->GetNextRuleId(),
11476 new System.Text.Parsing.SequenceParser(
11477 new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("UIntType"), 1),
11478 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11479 new System.Text.Parsing.NonterminalParser(ToUtf32("val"), ToUtf32("UIntValue"), 0)))));
11480 AddRule(new UIntValueRule(ToUtf32("UIntValue"), GetScope(), Domain()->GetNextRuleId(),
11481 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11482 new System.Text.Parsing.NonterminalParser(ToUtf32("x"), ToUtf32("uint"), 0))));
11483 AddRule(new LongConstantRule(ToUtf32("LongConstant"), GetScope(), Domain()->GetNextRuleId(),
11484 new System.Text.Parsing.SequenceParser(
11485 new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("LongType"), 1),
11486 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11487 new System.Text.Parsing.NonterminalParser(ToUtf32("val"), ToUtf32("LongValue"), 0)))));
11488 AddRule(new LongValueRule(ToUtf32("LongValue"), GetScope(), Domain()->GetNextRuleId(),
11489 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11490 new System.Text.Parsing.NonterminalParser(ToUtf32("x"), ToUtf32("long"), 0))));
11491 AddRule(new ULongConstantRule(ToUtf32("ULongConstant"), GetScope(), Domain()->GetNextRuleId(),
11492 new System.Text.Parsing.SequenceParser(
11493 new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("ULongType"), 1),
11494 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11495 new System.Text.Parsing.NonterminalParser(ToUtf32("val"), ToUtf32("ULongValue"), 0)))));
11496 AddRule(new ULongValueRule(ToUtf32("ULongValue"), GetScope(), Domain()->GetNextRuleId(),
11497 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11498 new System.Text.Parsing.NonterminalParser(ToUtf32("x"), ToUtf32("ulong"), 0))));
11499 AddRule(new FloatConstantRule(ToUtf32("FloatConstant"), GetScope(), Domain()->GetNextRuleId(),
11500 new System.Text.Parsing.SequenceParser(
11501 new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("FloatType"), 1),
11502 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11503 new System.Text.Parsing.NonterminalParser(ToUtf32("val"), ToUtf32("FloatValue"), 0)))));
11504 AddRule(new FloatValueRule(ToUtf32("FloatValue"), GetScope(), Domain()->GetNextRuleId(),
11505 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11506 new System.Text.Parsing.NonterminalParser(ToUtf32("x"), ToUtf32("float"), 0))));
11507 AddRule(new DoubleConstantRule(ToUtf32("DoubleConstant"), GetScope(), Domain()->GetNextRuleId(),
11508 new System.Text.Parsing.SequenceParser(
11509 new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("DoubleType"), 1),
11510 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11511 new System.Text.Parsing.NonterminalParser(ToUtf32("val"), ToUtf32("DoubleValue"), 0)))));
11512 AddRule(new DoubleValueRule(ToUtf32("DoubleValue"), GetScope(), Domain()->GetNextRuleId(),
11513 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11514 new System.Text.Parsing.NonterminalParser(ToUtf32("x"), ToUtf32("double"), 0))));
11515 AddRule(new ConversionConstantRule(ToUtf32("ConversionConstant"), GetScope(), Domain()->GetNextRuleId(),
11516 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11517 new System.Text.Parsing.GroupingParser(
11518 new System.Text.Parsing.SequenceParser(
11519 new System.Text.Parsing.SequenceParser(
11520 new System.Text.Parsing.SequenceParser(
11521 new System.Text.Parsing.SequenceParser(
11522 new System.Text.Parsing.NonterminalParser(ToUtf32("targetType"), ToUtf32("TypeExpr"), 1),
11523 new System.Text.Parsing.KeywordParser(ToUtf32("conv"))),
11524 new System.Text.Parsing.ExpectationParser(
11525 new System.Text.Parsing.CharParser('('))),
11526 new System.Text.Parsing.ExpectationParser(
11527 new System.Text.Parsing.NonterminalParser(ToUtf32("from"), ToUtf32("Constant"), 1))),
11528 new System.Text.Parsing.ExpectationParser(
11529 new System.Text.Parsing.CharParser(')')))))));
11530 AddRule(new ClsIdConstantRule(ToUtf32("ClsIdConstant"), GetScope(), Domain()->GetNextRuleId(),
11531 new System.Text.Parsing.SequenceParser(
11532 new System.Text.Parsing.SequenceParser(
11533 new System.Text.Parsing.SequenceParser(
11534 new System.Text.Parsing.SequenceParser(
11535 new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("TypeExpr"), 1),
11536 new System.Text.Parsing.KeywordParser(ToUtf32("clsid"))),
11537 new System.Text.Parsing.ExpectationParser(
11538 new System.Text.Parsing.CharParser('('))),
11539 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11540 new System.Text.Parsing.GroupingParser(
11541 new System.Text.Parsing.PositiveParser(
11542 new System.Text.Parsing.HexDigitParser())))),
11543 new System.Text.Parsing.ExpectationParser(
11544 new System.Text.Parsing.CharParser(')')))));
11545 AddRule(new PtrConstantRule(ToUtf32("PtrConstant"), GetScope(), Domain()->GetNextRuleId(),
11546 new System.Text.Parsing.AlternativeParser(
11547 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11548 new System.Text.Parsing.GroupingParser(
11549 new System.Text.Parsing.SequenceParser(
11550 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
11551 new System.Text.Parsing.NonterminalParser(ToUtf32("type1"), ToUtf32("TypeExpr"), 1)),
11552 new System.Text.Parsing.KeywordParser(ToUtf32("null"))))),
11553 new System.Text.Parsing.ActionParser(ToUtf32("A2"),
11554 new System.Text.Parsing.GroupingParser(
11555 new System.Text.Parsing.SequenceParser(
11556 new System.Text.Parsing.ActionParser(ToUtf32("A3"),
11557 new System.Text.Parsing.NonterminalParser(ToUtf32("type2"), ToUtf32("TypeExpr"), 1)),
11558 new System.Text.Parsing.NonterminalParser(ToUtf32("LiteralValue"), ToUtf32("LiteralValue"), 2)))))));
11559 AddRule(new SymbolConstantRule(ToUtf32("SymbolConstant"), GetScope(), Domain()->GetNextRuleId(),
11560 new System.Text.Parsing.SequenceParser(
11561 new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("TypeExpr"), 1),
11562 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11563 new System.Text.Parsing.NonterminalParser(ToUtf32("SymbolValue"), ToUtf32("SymbolValue"), 2)))));
11564 AddRule(new ArrayConstantRule(ToUtf32("ArrayConstant"), GetScope(), Domain()->GetNextRuleId(),
11565 new System.Text.Parsing.SequenceParser(
11566 new System.Text.Parsing.SequenceParser(
11567 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11568 new System.Text.Parsing.CharParser('[')),
11569 new System.Text.Parsing.OptionalParser(
11570 new System.Text.Parsing.GroupingParser(
11571 new System.Text.Parsing.ListParser(
11572 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
11573 new System.Text.Parsing.NonterminalParser(ToUtf32("element"), ToUtf32("Constant"), 1)),
11574 new System.Text.Parsing.CharParser(','))))),
11575 new System.Text.Parsing.CharParser(']'))));
11576 AddRule(new StructureConstantRule(ToUtf32("StructureConstant"), GetScope(), Domain()->GetNextRuleId(),
11577 new System.Text.Parsing.SequenceParser(
11578 new System.Text.Parsing.SequenceParser(
11579 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11580 new System.Text.Parsing.CharParser('{')),
11581 new System.Text.Parsing.OptionalParser(
11582 new System.Text.Parsing.GroupingParser(
11583 new System.Text.Parsing.ListParser(
11584 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
11585 new System.Text.Parsing.NonterminalParser(ToUtf32("member"), ToUtf32("Constant"), 1)),
11586 new System.Text.Parsing.CharParser(','))))),
11587 new System.Text.Parsing.CharParser('}'))));
11588 AddRule(new StringConstantRule(ToUtf32("StringConstant"), GetScope(), Domain()->GetNextRuleId(),
11589 new System.Text.Parsing.TokenParser(
11590 new System.Text.Parsing.SequenceParser(
11591 new System.Text.Parsing.SequenceParser(
11592 new System.Text.Parsing.CharParser('\"'),
11593 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11594 new System.Text.Parsing.GroupingParser(
11595 new System.Text.Parsing.KleeneStarParser(
11596 new System.Text.Parsing.CharSetParser(ToUtf32("\""), true))))),
11597 new System.Text.Parsing.CharParser('\"')))));
11598 AddRule(new StringArrayConstantRule(ToUtf32("StringArrayConstant"), GetScope(), Domain()->GetNextRuleId(),
11599 new System.Text.Parsing.SequenceParser(
11600 new System.Text.Parsing.SequenceParser(
11601 new System.Text.Parsing.SequenceParser(
11602 new System.Text.Parsing.NonterminalParser(ToUtf32("prefix"), ToUtf32("StringArrayPrefix"), 0),
11603 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11604 new System.Text.Parsing.CharParser('['))),
11605 new System.Text.Parsing.OptionalParser(
11606 new System.Text.Parsing.GroupingParser(
11607 new System.Text.Parsing.ListParser(
11608 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
11609 new System.Text.Parsing.NonterminalParser(ToUtf32("element"), ToUtf32("Constant"), 1)),
11610 new System.Text.Parsing.CharParser(','))))),
11611 new System.Text.Parsing.CharParser(']'))));
11612 AddRule(new StringArrayPrefixRule(ToUtf32("StringArrayPrefix"), GetScope(), Domain()->GetNextRuleId(),
11613 new System.Text.Parsing.AlternativeParser(
11614 new System.Text.Parsing.AlternativeParser(
11615 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11616 new System.Text.Parsing.CharParser('w')),
11617 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
11618 new System.Text.Parsing.CharParser('u'))),
11619 new System.Text.Parsing.ActionParser(ToUtf32("A2"),
11620 new System.Text.Parsing.CharParser('b')))));
11621 AddRule(new MetadataRule(ToUtf32("Metadata"), GetScope(), Domain()->GetNextRuleId(),
11622 new System.Text.Parsing.SequenceParser(
11623 new System.Text.Parsing.SequenceParser(
11624 new System.Text.Parsing.SequenceParser(
11625 new System.Text.Parsing.KeywordParser(ToUtf32("metadata")),
11626 new System.Text.Parsing.ExpectationParser(
11627 new System.Text.Parsing.CharParser('{'))),
11628 new System.Text.Parsing.KleeneStarParser(
11629 new System.Text.Parsing.NonterminalParser(ToUtf32("MDStruct"), ToUtf32("MDStruct"), 1))),
11630 new System.Text.Parsing.ExpectationParser(
11631 new System.Text.Parsing.CharParser('}')))));
11632 AddRule(new MDItemRule(ToUtf32("MDItem"), GetScope(), Domain()->GetNextRuleId(),
11633 new System.Text.Parsing.AlternativeParser(
11634 new System.Text.Parsing.AlternativeParser(
11635 new System.Text.Parsing.AlternativeParser(
11636 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11637 new System.Text.Parsing.NonterminalParser(ToUtf32("MDBool"), ToUtf32("MDBool"), 1)),
11638 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
11639 new System.Text.Parsing.NonterminalParser(ToUtf32("MDLong"), ToUtf32("MDLong"), 1))),
11640 new System.Text.Parsing.ActionParser(ToUtf32("A2"),
11641 new System.Text.Parsing.NonterminalParser(ToUtf32("MDString"), ToUtf32("MDString"), 1))),
11642 new System.Text.Parsing.ActionParser(ToUtf32("A3"),
11643 new System.Text.Parsing.NonterminalParser(ToUtf32("MDStructRef"), ToUtf32("MDStructRef"), 1)))));
11644 AddRule(new MDBoolRule(ToUtf32("MDBool"), GetScope(), Domain()->GetNextRuleId(),
11645 new System.Text.Parsing.AlternativeParser(
11646 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11647 new System.Text.Parsing.KeywordParser(ToUtf32("true"))),
11648 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
11649 new System.Text.Parsing.KeywordParser(ToUtf32("false"))))));
11650 AddRule(new MDLongRule(ToUtf32("MDLong"), GetScope(), Domain()->GetNextRuleId(),
11651 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11652 new System.Text.Parsing.NonterminalParser(ToUtf32("x"), ToUtf32("long"), 0))));
11653 AddRule(new MDStringRule(ToUtf32("MDString"), GetScope(), Domain()->GetNextRuleId(),
11654 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11655 new System.Text.Parsing.NonterminalParser(ToUtf32("s"), ToUtf32("string"), 0))));
11656 AddRule(new MDStructRefRule(ToUtf32("MDStructRef"), GetScope(), Domain()->GetNextRuleId(),
11657 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11658 new System.Text.Parsing.GroupingParser(
11659 new System.Text.Parsing.SequenceParser(
11660 new System.Text.Parsing.CharParser('!'),
11661 new System.Text.Parsing.NonterminalParser(ToUtf32("id"), ToUtf32("int"), 0))))));
11662 AddRule(new MDStructRule(ToUtf32("MDStruct"), GetScope(), Domain()->GetNextRuleId(),
11663 new System.Text.Parsing.SequenceParser(
11664 new System.Text.Parsing.SequenceParser(
11665 new System.Text.Parsing.SequenceParser(
11666 new System.Text.Parsing.SequenceParser(
11667 new System.Text.Parsing.SequenceParser(
11668 new System.Text.Parsing.CharParser('!'),
11669 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11670 new System.Text.Parsing.NonterminalParser(ToUtf32("id"), ToUtf32("int"), 0))),
11671 new System.Text.Parsing.CharParser('=')),
11672 new System.Text.Parsing.CharParser('{')),
11673 new System.Text.Parsing.OptionalParser(
11674 new System.Text.Parsing.GroupingParser(
11675 new System.Text.Parsing.ListParser(
11676 new System.Text.Parsing.NonterminalParser(ToUtf32("field"), ToUtf32("MDField"), 2),
11677 new System.Text.Parsing.CharParser(','))))),
11678 new System.Text.Parsing.CharParser('}'))));
11679 AddRule(new MDFieldRule(ToUtf32("MDField"), GetScope(), Domain()->GetNextRuleId(),
11680 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
11681 new System.Text.Parsing.GroupingParser(
11682 new System.Text.Parsing.SequenceParser(
11683 new System.Text.Parsing.SequenceParser(
11684 new System.Text.Parsing.NonterminalParser(ToUtf32("fieldName"), ToUtf32("identifier"), 0),
11685 new System.Text.Parsing.CharParser(':')),
11686 new System.Text.Parsing.NonterminalParser(ToUtf32("item"), ToUtf32("MDItem"), 1))))));
11687 SetSkipRuleName(ToUtf32("spaces"));
11688 }
11689 private List<ustring> keywords0;
11690 }
11691 }